diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,86 @@ --- +## [0.18.0] - 2026-09-29 + +Module-naming systematization release: every kernel and package module moves onto a uniform +`hydra.core.*` / `hydra..*` grammar, completing the package ⊃ module ⊃ definition containment +tower. The rename touches every module, definition, and cross-host reference in the codebase; this +release exists primarily to ship it as its own coordinated batch. Also lands the translingual regex +primitive pipeline and several silent-correctness fixes in the coder layer. + +### Highlights + +- **Module-name grammar systematization** ([#729](https://github.com/CategoricalData/hydra/issues/729)): + every `hydra.*` module renamed onto a uniform package-derived prefix — kernel modules move to + `hydra.core.*`, package modules to `hydra..*` — closing the long-standing inconsistency where + a package name had no structural relationship to the module names it contained. The rename spans + every host (Haskell, Java, Python, Scala, TypeScript, all four Lisp dialects) and required fixing + stale namespace references, overlay-directory paths, and `hostOverrides` shims across every driver + and bootstrap script that had hardcoded the old grammar. Further consolidation (a structurally + enforced package↔prefix law) is tracked for 0.18.1. The kernel package itself is still published as + `hydra-kernel` (its modules are under `hydra.core.*`); the `hydra-core` package rename #729 called for + is under review because that name is taken on PyPI and npm + ([#770](https://github.com/CategoricalData/hydra/issues/770)). +- **Translingual regex primitives** ([#603](https://github.com/CategoricalData/hydra/issues/603)): + `hydra.lib.regex` primitives (`find`, `findAll`, `matches`, `replace`, `replaceAll`, `split`) now run + every pattern through the shared `hydra.regex` parse/print pipeline instead of handing raw pattern + strings to each host's native engine, so a pattern means the same thing on every host. Includes a + host-independent conformance suite and a leftmost-longest alternation fix in the PCRE/POSIX printers. +- **Silent-corruption fixes across the coder layer** + ([#744](https://github.com/CategoricalData/hydra/issues/744), + [#765](https://github.com/CategoricalData/hydra/issues/765), + [#649](https://github.com/CategoricalData/hydra/issues/649)): fixed data-corrupting bugs in the + JSON-Schema/Avro/GraphQL/GraphSON/Protobuf coders (extended integer widths, map-key handling), the + kernel's encode/decode generators (reversed type-parameter order on 2+-param polymorphic types), and + the Python coder (silently dropping a module's types when types and terms share a file path). +- **Self-hosted specification docs** ([#723](https://github.com/CategoricalData/hydra/issues/723)): + the module-reference pages under `docs/specification/` are now generated directly from the kernel + (`bin/regenerate-spec.sh`) via a new metadata-only doc coder, rather than hand-maintained. + +### New features + +- **[#603](https://github.com/CategoricalData/hydra/issues/603)** host-independent regex conformance + suite covering the minimal-core grammar (literals, classes, quantifiers, alternation, anchors, + grouping) across all 9 hosts. +- **[#723](https://github.com/CategoricalData/hydra/issues/723)** `hydra.markdown` type module and + `generateModuleDoc`, the metadata-only doc coder backing the self-generated spec pages. +- **[#382](https://github.com/CategoricalData/hydra/issues/382)** the Rust coder is split out of + `hydra-ext` into its own first-class `hydra-rust` package. + +### Bug fixes + +- **[#744](https://github.com/CategoricalData/hydra/issues/744)** silent data corruption in + JSON-Schema/Avro/GraphQL/GraphSON/Protobuf coders for extended integer widths and map-key handling. +- **[#765](https://github.com/CategoricalData/hydra/issues/765)** kernel encode/decode generators + emitted reversed type-parameter order for 2+-param polymorphic types. +- **[#649](https://github.com/CategoricalData/hydra/issues/649)** Python coder silently dropped a + module's types when types and terms targeted the same output file path. +- **[#572](https://github.com/CategoricalData/hydra/issues/572)** TypeScript kernel-JSON test + bridge's compact-form decode heuristic mishandled nullary union arms. +- **[#761](https://github.com/CategoricalData/hydra/issues/761)** cold-seed generation ignored + `hostOverrides.java=local`, silently pulling the published Java host jar instead. +- **[#736](https://github.com/CategoricalData/hydra/issues/736)** Java build now pins JDK 11 via a + Gradle toolchain block, instead of depending on ambient `JAVA_HOME`. + +### Improvements + +- **[#327](https://github.com/CategoricalData/hydra/issues/327)** new `hydra.diff` schema-diff type + module; `Term.Inject` comparison is now by variant name. +- **[#573](https://github.com/CategoricalData/hydra/issues/573)** per-registry publish sets (Hackage, + Maven, PyPI, npm) are now derived from the package registry itself instead of 13 hand-maintained + lists — closes a recurring class of silent release-time drift. +- **[#735](https://github.com/CategoricalData/hydra/issues/735)** cross-host decimal-scale test + filtering now driven by a translingual `scaleDistinct` capability tag instead of hand-copied + per-host skip lists. + +### Documentation + +- **[#655](https://github.com/CategoricalData/hydra/issues/655)** documented the overlay-emission + "implementation wins" decision for bare primitive references (`docs/overlays.md`). + +--- + ## [0.17.7] - 2026-09-14 Correctness-hardening point release on the 0.17.x line, consolidating the 0.17.6 breaking batch. It diff --git a/hydra-build.cabal b/hydra-build.cabal --- a/hydra-build.cabal +++ b/hydra-build.cabal @@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack name: hydra-build -version: 0.17.7 +version: 0.18.0 synopsis: Hydra's build system, promoted into Hydra 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 Hydra's build system, promoted into Hydra itself: the manifest-derived module-to-package router, kernel/host reconciliation utilities, and pure module-list helpers, expressed as Hydra modules and generated into every self-hosting dialect. It builds on hydra-kernel. category: Data @@ -32,6 +32,18 @@ Hydra.Build.Benchresult Hydra.Build.Comparereport Hydra.Build.Comparereportlogic + Hydra.Build.Decode.Assembly + Hydra.Build.Decode.Benchresult + Hydra.Build.Decode.Comparereport + Hydra.Build.Decode.Format + Hydra.Build.Dsl.Assembly + Hydra.Build.Dsl.Benchresult + Hydra.Build.Dsl.Comparereport + Hydra.Build.Dsl.Format + Hydra.Build.Encode.Assembly + Hydra.Build.Encode.Benchresult + Hydra.Build.Encode.Comparereport + Hydra.Build.Encode.Format Hydra.Build.Format Hydra.Build.Langexpansion Hydra.Build.Libraries @@ -45,18 +57,6 @@ Hydra.Build.Syncmatrix Hydra.Build.Versionconsistency Hydra.Build.Walk - Hydra.Decode.Build.Assembly - Hydra.Decode.Build.Benchresult - Hydra.Decode.Build.Comparereport - Hydra.Decode.Build.Format - Hydra.Dsl.Build.Assembly - Hydra.Dsl.Build.Benchresult - Hydra.Dsl.Build.Comparereport - Hydra.Dsl.Build.Format - Hydra.Encode.Build.Assembly - Hydra.Encode.Build.Benchresult - Hydra.Encode.Build.Comparereport - Hydra.Encode.Build.Format other-modules: Paths_hydra_build hs-source-dirs: @@ -64,6 +64,6 @@ build-depends: base >=4.19.0 && <4.22 , containers >=0.6.7 && <0.8 - , hydra-kernel ==0.17.7 + , hydra-kernel ==0.18.0 , scientific >=0.3.7 && <0.4 default-language: Haskell2010 diff --git a/src/main/haskell/Hydra/Build/Assembly.hs b/src/main/haskell/Hydra/Build/Assembly.hs --- a/src/main/haskell/Hydra/Build/Assembly.hs +++ b/src/main/haskell/Hydra/Build/Assembly.hs @@ -4,7 +4,7 @@ module Hydra.Build.Assembly where -import qualified Hydra.Core as Core +import qualified Hydra.Core.Model as Model import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void @@ -22,15 +22,15 @@ assemblyEntryExclude :: [String]} deriving (Eq, Ord, Read, Show) -_AssemblyEntry = Core.Name "hydra.build.assembly.AssemblyEntry" +_AssemblyEntry = Model.Name "hydra.build.assembly.AssemblyEntry" -_AssemblyEntry_sourceTree = Core.Name "sourceTree" +_AssemblyEntry_sourceTree = Model.Name "sourceTree" -_AssemblyEntry_destTree = Core.Name "destTree" +_AssemblyEntry_destTree = Model.Name "destTree" -_AssemblyEntry_kind = Core.Name "kind" +_AssemblyEntry_kind = Model.Name "kind" -_AssemblyEntry_exclude = Core.Name "exclude" +_AssemblyEntry_exclude = Model.Name "exclude" -- | How an assembly entry's source tree is realized at its destination. The distinction gates the host-native executor's dispatch (merge-copy vs. wipe-then-copy vs. symlink). data AssemblyEntryKind = @@ -44,15 +44,15 @@ AssemblyEntryKindSymlinkDir deriving (Eq, Ord, Read, Show) -_AssemblyEntryKind = Core.Name "hydra.build.assembly.AssemblyEntryKind" +_AssemblyEntryKind = Model.Name "hydra.build.assembly.AssemblyEntryKind" -_AssemblyEntryKind_merge = Core.Name "merge" +_AssemblyEntryKind_merge = Model.Name "merge" -_AssemblyEntryKind_wipeThenCopy = Core.Name "wipeThenCopy" +_AssemblyEntryKind_wipeThenCopy = Model.Name "wipeThenCopy" -_AssemblyEntryKind_symlinkTree = Core.Name "symlinkTree" +_AssemblyEntryKind_symlinkTree = Model.Name "symlinkTree" -_AssemblyEntryKind_symlinkDir = Core.Name "symlinkDir" +_AssemblyEntryKind_symlinkDir = Model.Name "symlinkDir" -- | The complete assembly plan for one distribution package in one target language: the ordered copy/symlink entries to realize and the keep-paths a pruning consumer must protect. Entries are ordered because realization order can matter (e.g. a package that links its own subtree back into an already-assembled dependency's tree). data AssemblyPlan = @@ -63,11 +63,11 @@ assemblyPlanKeepPaths :: [KeepPathEntry]} deriving (Eq, Ord, Read, Show) -_AssemblyPlan = Core.Name "hydra.build.assembly.AssemblyPlan" +_AssemblyPlan = Model.Name "hydra.build.assembly.AssemblyPlan" -_AssemblyPlan_entries = Core.Name "entries" +_AssemblyPlan_entries = Model.Name "entries" -_AssemblyPlan_keepPaths = Core.Name "keepPaths" +_AssemblyPlan_keepPaths = Model.Name "keepPaths" -- | One protected path in a keep-paths manifest: a source-set directory paired with a file's path relative to it. Serialized by the native executor as \t, bit-compatible with the prune-stale (#357) and digest-check --keep-paths-from consumers. data KeepPathEntry = @@ -78,8 +78,8 @@ keepPathEntryRelPath :: String} deriving (Eq, Ord, Read, Show) -_KeepPathEntry = Core.Name "hydra.build.assembly.KeepPathEntry" +_KeepPathEntry = Model.Name "hydra.build.assembly.KeepPathEntry" -_KeepPathEntry_sourceSetDir = Core.Name "sourceSetDir" +_KeepPathEntry_sourceSetDir = Model.Name "sourceSetDir" -_KeepPathEntry_relPath = Core.Name "relPath" +_KeepPathEntry_relPath = Model.Name "relPath" diff --git a/src/main/haskell/Hydra/Build/Assemblyplan.hs b/src/main/haskell/Hydra/Build/Assemblyplan.hs --- a/src/main/haskell/Hydra/Build/Assemblyplan.hs +++ b/src/main/haskell/Hydra/Build/Assemblyplan.hs @@ -4,38 +4,40 @@ module Hydra.Build.Assemblyplan 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.Pairs as Pairs -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -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.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void diff --git a/src/main/haskell/Hydra/Build/Benchresult.hs b/src/main/haskell/Hydra/Build/Benchresult.hs --- a/src/main/haskell/Hydra/Build/Benchresult.hs +++ b/src/main/haskell/Hydra/Build/Benchresult.hs @@ -4,7 +4,7 @@ module Hydra.Build.Benchresult where -import qualified Hydra.Core as Core +import qualified Hydra.Core.Model as Model import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void @@ -25,17 +25,17 @@ benchMetadataCommitMessage :: String} deriving (Eq, Ord, Read, Show) -_BenchMetadata = Core.Name "hydra.build.benchresult.BenchMetadata" +_BenchMetadata = Model.Name "hydra.build.benchresult.BenchMetadata" -_BenchMetadata_timestamp = Core.Name "timestamp" +_BenchMetadata_timestamp = Model.Name "timestamp" -_BenchMetadata_language = Core.Name "language" +_BenchMetadata_language = Model.Name "language" -_BenchMetadata_branch = Core.Name "branch" +_BenchMetadata_branch = Model.Name "branch" -_BenchMetadata_commit = Core.Name "commit" +_BenchMetadata_commit = Model.Name "commit" -_BenchMetadata_commitMessage = Core.Name "commitMessage" +_BenchMetadata_commitMessage = Model.Name "commitMessage" -- | A generator-benchmark result: target, run count, and per-host results data GenBenchResult = @@ -50,15 +50,15 @@ genBenchResultMetadata :: (Maybe BenchMetadata)} deriving (Eq, Ord, Read, Show) -_GenBenchResult = Core.Name "hydra.build.benchresult.GenBenchResult" +_GenBenchResult = Model.Name "hydra.build.benchresult.GenBenchResult" -_GenBenchResult_target = Core.Name "target" +_GenBenchResult_target = Model.Name "target" -_GenBenchResult_runs = Core.Name "runs" +_GenBenchResult_runs = Model.Name "runs" -_GenBenchResult_hosts = Core.Name "hosts" +_GenBenchResult_hosts = Model.Name "hosts" -_GenBenchResult_metadata = Core.Name "metadata" +_GenBenchResult_metadata = Model.Name "metadata" -- | One host's generator-benchmark result: setup time and per-package timings data HostResult = @@ -69,11 +69,11 @@ hostResultPackages :: (M.Map String RunStats)} deriving (Eq, Ord, Read, Show) -_HostResult = Core.Name "hydra.build.benchresult.HostResult" +_HostResult = Model.Name "hydra.build.benchresult.HostResult" -_HostResult_setupMs = Core.Name "setupMs" +_HostResult_setupMs = Model.Name "setupMs" -_HostResult_packages = Core.Name "packages" +_HostResult_packages = Model.Name "packages" -- | Timing statistics for one (host, package): per-run elapsed times and the median data RunStats = @@ -84,8 +84,8 @@ runStatsMedianMs :: Int} deriving (Eq, Ord, Read, Show) -_RunStats = Core.Name "hydra.build.benchresult.RunStats" +_RunStats = Model.Name "hydra.build.benchresult.RunStats" -_RunStats_runsMs = Core.Name "runsMs" +_RunStats_runsMs = Model.Name "runsMs" -_RunStats_medianMs = Core.Name "medianMs" +_RunStats_medianMs = Model.Name "medianMs" diff --git a/src/main/haskell/Hydra/Build/Comparereport.hs b/src/main/haskell/Hydra/Build/Comparereport.hs --- a/src/main/haskell/Hydra/Build/Comparereport.hs +++ b/src/main/haskell/Hydra/Build/Comparereport.hs @@ -4,7 +4,7 @@ module Hydra.Build.Comparereport where -import qualified Hydra.Core as Core +import qualified Hydra.Core.Model as Model import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void @@ -20,13 +20,13 @@ compareReportTotal :: Int} deriving (Eq, Ord, Read, Show) -_CompareReport = Core.Name "hydra.build.comparereport.CompareReport" +_CompareReport = Model.Name "hydra.build.comparereport.CompareReport" -_CompareReport_rows = Core.Name "rows" +_CompareReport_rows = Model.Name "rows" -_CompareReport_byteEqCount = Core.Name "byteEqCount" +_CompareReport_byteEqCount = Model.Name "byteEqCount" -_CompareReport_total = Core.Name "total" +_CompareReport_total = Model.Name "total" -- | The result of comparing one module's JSON on the two sides data CompareStatus = @@ -38,13 +38,13 @@ CompareStatusMissing deriving (Eq, Ord, Read, Show) -_CompareStatus = Core.Name "hydra.build.comparereport.CompareStatus" +_CompareStatus = Model.Name "hydra.build.comparereport.CompareStatus" -_CompareStatus_byteEq = Core.Name "byteEq" +_CompareStatus_byteEq = Model.Name "byteEq" -_CompareStatus_differ = Core.Name "differ" +_CompareStatus_differ = Model.Name "differ" -_CompareStatus_missing = Core.Name "missing" +_CompareStatus_missing = Model.Name "missing" -- | One module's comparison record data ModuleCompare = @@ -61,14 +61,14 @@ moduleCompareDiffLines :: Int} deriving (Eq, Ord, Read, Show) -_ModuleCompare = Core.Name "hydra.build.comparereport.ModuleCompare" +_ModuleCompare = Model.Name "hydra.build.comparereport.ModuleCompare" -_ModuleCompare_module = Core.Name "module" +_ModuleCompare_module = Model.Name "module" -_ModuleCompare_status = Core.Name "status" +_ModuleCompare_status = Model.Name "status" -_ModuleCompare_ourSize = Core.Name "ourSize" +_ModuleCompare_ourSize = Model.Name "ourSize" -_ModuleCompare_canonSize = Core.Name "canonSize" +_ModuleCompare_canonSize = Model.Name "canonSize" -_ModuleCompare_diffLines = Core.Name "diffLines" +_ModuleCompare_diffLines = Model.Name "diffLines" diff --git a/src/main/haskell/Hydra/Build/Comparereportlogic.hs b/src/main/haskell/Hydra/Build/Comparereportlogic.hs --- a/src/main/haskell/Hydra/Build/Comparereportlogic.hs +++ b/src/main/haskell/Hydra/Build/Comparereportlogic.hs @@ -4,45 +4,47 @@ module Hydra.Build.Comparereportlogic where -import qualified Hydra.Ast as Ast import qualified Hydra.Build.Walk as Walk -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.Equality as Equality -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals -import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic -import qualified Hydra.Overlay.Haskell.Lib.Math as Math -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Ordering as Ordering -import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -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.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Literals as Literals +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Math as Math +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Ordering as Ordering +import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void diff --git a/src/main/haskell/Hydra/Build/Decode/Assembly.hs b/src/main/haskell/Hydra/Build/Decode/Assembly.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Build/Decode/Assembly.hs @@ -0,0 +1,102 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Term decoders for hydra.build.assembly + +module Hydra.Build.Decode.Assembly where + +import qualified Hydra.Build.Assembly as Assembly +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.Extract.Model as ExtractModel +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Lexical as Lexical +import qualified Hydra.Core.Overlay.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Rewriting as Rewriting +import qualified Hydra.Core.Util as Util +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Decoder for hydra.build.assembly.AssemblyEntry +assemblyEntry :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Assembly.AssemblyEntry +assemblyEntry cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "sourceTree" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_sourceTree -> Eithers.bind (ExtractModel.requireField "destTree" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_destTree -> Eithers.bind (ExtractModel.requireField "kind" assemblyEntryKind fieldMap cx) (\field_kind -> Eithers.bind (ExtractModel.requireField "exclude" (ExtractModel.decodeList (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_exclude -> Right (Assembly.AssemblyEntry { + Assembly.assemblyEntrySourceTree = field_sourceTree, + Assembly.assemblyEntryDestTree = field_destTree, + Assembly.assemblyEntryKind = field_kind, + Assembly.assemblyEntryExclude = field_exclude})))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.assembly.AssemblyEntry")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.assembly.AssemblyEntryKind +assemblyEntryKind :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Assembly.AssemblyEntryKind +assemblyEntryKind cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermInject v0 -> + let field = Model.injectionField v0 + fname = Model.fieldName field + fterm = Model.fieldTerm field + variantMap = + Maps.fromList [ + (Model.Name "merge", (\input -> Eithers.map (\t -> Assembly.AssemblyEntryKindMerge) (ExtractModel.decodeUnit cx input))), + ( + Model.Name "wipeThenCopy", + (\input -> Eithers.map (\t -> Assembly.AssemblyEntryKindWipeThenCopy) (ExtractModel.decodeUnit cx input))), + ( + Model.Name "symlinkTree", + (\input -> Eithers.map (\t -> Assembly.AssemblyEntryKindSymlinkTree) (ExtractModel.decodeUnit cx input))), + ( + Model.Name "symlinkDir", + (\input -> Eithers.map (\t -> Assembly.AssemblyEntryKindSymlinkDir) (ExtractModel.decodeUnit cx input)))] + in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [ + "no such field ", + (Model.unName fname), + " in union"]))) (\f -> f fterm)) + _ -> Left (Errors.DecodingError "expected union")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.assembly.AssemblyPlan +assemblyPlan :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Assembly.AssemblyPlan +assemblyPlan cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "entries" (ExtractModel.decodeList assemblyEntry) fieldMap cx) (\field_entries -> Eithers.bind (ExtractModel.requireField "keepPaths" (ExtractModel.decodeList keepPathEntry) fieldMap cx) (\field_keepPaths -> Right (Assembly.AssemblyPlan { + Assembly.assemblyPlanEntries = field_entries, + Assembly.assemblyPlanKeepPaths = field_keepPaths})))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.assembly.AssemblyPlan")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.assembly.KeepPathEntry +keepPathEntry :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Assembly.KeepPathEntry +keepPathEntry cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "sourceSetDir" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_sourceSetDir -> Eithers.bind (ExtractModel.requireField "relPath" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_relPath -> Right (Assembly.KeepPathEntry { + Assembly.keepPathEntrySourceSetDir = field_sourceSetDir, + Assembly.keepPathEntryRelPath = field_relPath})))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.assembly.KeepPathEntry")) (ExtractModel.stripWithDecodingError cx raw) diff --git a/src/main/haskell/Hydra/Build/Decode/Benchresult.hs b/src/main/haskell/Hydra/Build/Decode/Benchresult.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Build/Decode/Benchresult.hs @@ -0,0 +1,123 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Term decoders for hydra.build.benchresult + +module Hydra.Build.Decode.Benchresult where + +import qualified Hydra.Build.Benchresult as Benchresult +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.Extract.Model as ExtractModel +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Lexical as Lexical +import qualified Hydra.Core.Overlay.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Rewriting as Rewriting +import qualified Hydra.Core.Util as Util +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Decoder for hydra.build.benchresult.BenchMetadata +benchMetadata :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Benchresult.BenchMetadata +benchMetadata cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "timestamp" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_timestamp -> Eithers.bind (ExtractModel.requireField "language" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_language -> Eithers.bind (ExtractModel.requireField "branch" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_branch -> Eithers.bind (ExtractModel.requireField "commit" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_commit -> Eithers.bind (ExtractModel.requireField "commitMessage" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_commitMessage -> Right (Benchresult.BenchMetadata { + Benchresult.benchMetadataTimestamp = field_timestamp, + Benchresult.benchMetadataLanguage = field_language, + Benchresult.benchMetadataBranch = field_branch, + Benchresult.benchMetadataCommit = field_commit, + Benchresult.benchMetadataCommitMessage = field_commitMessage}))))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.benchresult.BenchMetadata")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.benchresult.GenBenchResult +genBenchResult :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Benchresult.GenBenchResult +genBenchResult cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "target" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_target -> Eithers.bind (ExtractModel.requireField "runs" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralInteger v2 -> case v2 of + Model.IntegerValueInt32 v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected int32 value") + _ -> Left (Errors.DecodingError "expected int32 literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_runs -> Eithers.bind (ExtractModel.requireField "hosts" (ExtractModel.decodeMap (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) hostResult) fieldMap cx) (\field_hosts -> Eithers.bind (ExtractModel.requireField "metadata" (ExtractModel.decodeMaybe benchMetadata) fieldMap cx) (\field_metadata -> Right (Benchresult.GenBenchResult { + Benchresult.genBenchResultTarget = field_target, + Benchresult.genBenchResultRuns = field_runs, + Benchresult.genBenchResultHosts = field_hosts, + Benchresult.genBenchResultMetadata = field_metadata})))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.benchresult.GenBenchResult")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.benchresult.HostResult +hostResult :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Benchresult.HostResult +hostResult cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "setupMs" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralInteger v2 -> case v2 of + Model.IntegerValueInt32 v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected int32 value") + _ -> Left (Errors.DecodingError "expected int32 literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_setupMs -> Eithers.bind (ExtractModel.requireField "packages" (ExtractModel.decodeMap (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) runStats) fieldMap cx) (\field_packages -> Right (Benchresult.HostResult { + Benchresult.hostResultSetupMs = field_setupMs, + Benchresult.hostResultPackages = field_packages})))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.benchresult.HostResult")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.benchresult.RunStats +runStats :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Benchresult.RunStats +runStats cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "runsMs" (ExtractModel.decodeList (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralInteger v2 -> case v2 of + Model.IntegerValueInt32 v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected int32 value") + _ -> Left (Errors.DecodingError "expected int32 literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_runsMs -> Eithers.bind (ExtractModel.requireField "medianMs" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralInteger v2 -> case v2 of + Model.IntegerValueInt32 v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected int32 value") + _ -> Left (Errors.DecodingError "expected int32 literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_medianMs -> Right (Benchresult.RunStats { + Benchresult.runStatsRunsMs = field_runsMs, + Benchresult.runStatsMedianMs = field_medianMs})))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.benchresult.RunStats")) (ExtractModel.stripWithDecodingError cx raw) diff --git a/src/main/haskell/Hydra/Build/Decode/Comparereport.hs b/src/main/haskell/Hydra/Build/Decode/Comparereport.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Build/Decode/Comparereport.hs @@ -0,0 +1,106 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Term decoders for hydra.build.comparereport + +module Hydra.Build.Decode.Comparereport where + +import qualified Hydra.Build.Comparereport as Comparereport +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.Extract.Model as ExtractModel +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Lexical as Lexical +import qualified Hydra.Core.Overlay.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Rewriting as Rewriting +import qualified Hydra.Core.Util as Util +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Decoder for hydra.build.comparereport.CompareReport +compareReport :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Comparereport.CompareReport +compareReport cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "rows" (ExtractModel.decodeList moduleCompare) fieldMap cx) (\field_rows -> Eithers.bind (ExtractModel.requireField "byteEqCount" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralInteger v2 -> case v2 of + Model.IntegerValueInt32 v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected int32 value") + _ -> Left (Errors.DecodingError "expected int32 literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_byteEqCount -> Eithers.bind (ExtractModel.requireField "total" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralInteger v2 -> case v2 of + Model.IntegerValueInt32 v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected int32 value") + _ -> Left (Errors.DecodingError "expected int32 literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_total -> Right (Comparereport.CompareReport { + Comparereport.compareReportRows = field_rows, + Comparereport.compareReportByteEqCount = field_byteEqCount, + Comparereport.compareReportTotal = field_total}))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.comparereport.CompareReport")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.comparereport.CompareStatus +compareStatus :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Comparereport.CompareStatus +compareStatus cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermInject v0 -> + let field = Model.injectionField v0 + fname = Model.fieldName field + fterm = Model.fieldTerm field + variantMap = + Maps.fromList [ + ( + Model.Name "byteEq", + (\input -> Eithers.map (\t -> Comparereport.CompareStatusByteEq) (ExtractModel.decodeUnit cx input))), + ( + Model.Name "differ", + (\input -> Eithers.map (\t -> Comparereport.CompareStatusDiffer) (ExtractModel.decodeUnit cx input))), + ( + Model.Name "missing", + (\input -> Eithers.map (\t -> Comparereport.CompareStatusMissing) (ExtractModel.decodeUnit cx input)))] + in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [ + "no such field ", + (Model.unName fname), + " in union"]))) (\f -> f fterm)) + _ -> Left (Errors.DecodingError "expected union")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.comparereport.ModuleCompare +moduleCompare :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Comparereport.ModuleCompare +moduleCompare cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "module" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_module -> Eithers.bind (ExtractModel.requireField "status" compareStatus fieldMap cx) (\field_status -> Eithers.bind (ExtractModel.requireField "ourSize" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralInteger v2 -> case v2 of + Model.IntegerValueInt32 v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected int32 value") + _ -> Left (Errors.DecodingError "expected int32 literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_ourSize -> Eithers.bind (ExtractModel.requireField "canonSize" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralInteger v2 -> case v2 of + Model.IntegerValueInt32 v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected int32 value") + _ -> Left (Errors.DecodingError "expected int32 literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_canonSize -> Eithers.bind (ExtractModel.requireField "diffLines" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralInteger v2 -> case v2 of + Model.IntegerValueInt32 v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected int32 value") + _ -> Left (Errors.DecodingError "expected int32 literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_diffLines -> Right (Comparereport.ModuleCompare { + Comparereport.moduleCompareModule = field_module, + Comparereport.moduleCompareStatus = field_status, + Comparereport.moduleCompareOurSize = field_ourSize, + Comparereport.moduleCompareCanonSize = field_canonSize, + Comparereport.moduleCompareDiffLines = field_diffLines}))))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.comparereport.ModuleCompare")) (ExtractModel.stripWithDecodingError cx raw) diff --git a/src/main/haskell/Hydra/Build/Decode/Format.hs b/src/main/haskell/Hydra/Build/Decode/Format.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Build/Decode/Format.hs @@ -0,0 +1,444 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Term decoders for hydra.build.format + +module Hydra.Build.Decode.Format where + +import qualified Hydra.Build.Format as Format +import qualified Hydra.Core.Decode.Packaging as Packaging +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.Extract.Model as ExtractModel +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Lexical as Lexical +import qualified Hydra.Core.Overlay.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Rewriting as Rewriting +import qualified Hydra.Core.Util as Util +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Decoder for hydra.build.format.DefinitionNameConventionProfile +definitionNameConventionProfile :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.DefinitionNameConventionProfile +definitionNameConventionProfile cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "severity" severity fieldMap cx) (\field_severity -> Eithers.bind (ExtractModel.requireField "allowUnderscores" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralBoolean v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected boolean literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_allowUnderscores -> Right (Format.DefinitionNameConventionProfile { + Format.definitionNameConventionProfileSeverity = field_severity, + Format.definitionNameConventionProfileAllowUnderscores = field_allowUnderscores})))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.DefinitionNameConventionProfile")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.DefinitionValidationProfile +definitionValidationProfile :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.DefinitionValidationProfile +definitionValidationProfile cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "hasDescription" (ExtractModel.decodeMaybe documentationProfile) fieldMap cx) (\field_hasDescription -> Eithers.bind (ExtractModel.requireField "ordering" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_ordering -> Eithers.bind (ExtractModel.requireField "nameConvention" (ExtractModel.decodeMaybe definitionNameConventionProfile) fieldMap cx) (\field_nameConvention -> Eithers.bind (ExtractModel.requireField "notInModuleName" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_notInModuleName -> Eithers.bind (ExtractModel.requireField "duplicateName" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_duplicateName -> Right (Format.DefinitionValidationProfile { + Format.definitionValidationProfileHasDescription = field_hasDescription, + Format.definitionValidationProfileOrdering = field_ordering, + Format.definitionValidationProfileNameConvention = field_nameConvention, + Format.definitionValidationProfileNotInModuleName = field_notInModuleName, + Format.definitionValidationProfileDuplicateName = field_duplicateName}))))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.DefinitionValidationProfile")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.DigestEntry +digestEntry :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.DigestEntry +digestEntry cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "kind" digestKind fieldMap cx) (\field_kind -> Eithers.bind (ExtractModel.requireField "hash" sha256Hash fieldMap cx) (\field_hash -> Right (Format.DigestEntry { + Format.digestEntryKind = field_kind, + Format.digestEntryHash = field_hash})))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.DigestEntry")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.DigestKind +digestKind :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.DigestKind +digestKind cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermInject v0 -> + let field = Model.injectionField v0 + fname = Model.fieldName field + fterm = Model.fieldTerm field + variantMap = + Maps.fromList [ + (Model.Name "dslSource", (\input -> Eithers.map (\t -> Format.DigestKindDslSource) (ExtractModel.decodeUnit cx input))), + (Model.Name "jsonFile", (\input -> Eithers.map (\t -> Format.DigestKindJsonFile) (ExtractModel.decodeUnit cx input))), + (Model.Name "targetFile", (\input -> Eithers.map (\t -> Format.DigestKindTargetFile) (ExtractModel.decodeUnit cx input))), + ( + Model.Name "runtimeFile", + (\input -> Eithers.map (\t -> Format.DigestKindRuntimeFile) (ExtractModel.decodeUnit cx input))), + (Model.Name "other", (\input -> Eithers.map (\t -> Format.DigestKindOther) (ExtractModel.decodeUnit cx input)))] + in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [ + "no such field ", + (Model.unName fname), + " in union"]))) (\f -> f fterm)) + _ -> Left (Errors.DecodingError "expected union")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.DocumentationProfile +documentationProfile :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.DocumentationProfile +documentationProfile cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "severity" severity fieldMap cx) (\field_severity -> Eithers.bind (ExtractModel.requireField "exemptDeprecated" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralBoolean v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected boolean literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_exemptDeprecated -> Right (Format.DocumentationProfile { + Format.documentationProfileSeverity = field_severity, + Format.documentationProfileExemptDeprecated = field_exemptDeprecated})))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.DocumentationProfile")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.Generation +generation :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.Generation +generation cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "generatorId" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_generatorId -> Eithers.bind (ExtractModel.requireField "mode" generationMode fieldMap cx) (\field_mode -> Eithers.bind (ExtractModel.requireField "host" languageName fieldMap cx) (\field_host -> Eithers.bind (ExtractModel.requireField "hydraVersion" (ExtractModel.decodeMaybe Packaging.version) fieldMap cx) (\field_hydraVersion -> Eithers.bind (ExtractModel.requireField "revision" (ExtractModel.decodeMaybe (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_revision -> Eithers.bind (ExtractModel.requireField "timestamp" (ExtractModel.decodeMaybe (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_timestamp -> Right (Format.Generation { + Format.generationGeneratorId = field_generatorId, + Format.generationMode = field_mode, + Format.generationHost = field_host, + Format.generationHydraVersion = field_hydraVersion, + Format.generationRevision = field_revision, + Format.generationTimestamp = field_timestamp})))))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.Generation")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.GenerationMode +generationMode :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.GenerationMode +generationMode cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermInject v0 -> + let field = Model.injectionField v0 + fname = Model.fieldName field + fterm = Model.fieldTerm field + variantMap = + Maps.fromList [ + ( + Model.Name "published", + (\input -> Eithers.map (\t -> Format.GenerationModePublished) (ExtractModel.decodeUnit cx input))), + (Model.Name "shim", (\input -> Eithers.map (\t -> Format.GenerationModeShim) (ExtractModel.decodeUnit cx input)))] + in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [ + "no such field ", + (Model.unName fname), + " in union"]))) (\f -> f fterm)) + _ -> Left (Errors.DecodingError "expected union")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.HostOverride +hostOverride :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.HostOverride +hostOverride cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermInject v0 -> + let field = Model.injectionField v0 + fname = Model.fieldName field + fterm = Model.fieldTerm field + variantMap = + Maps.fromList [ + (Model.Name "local", (\input -> Eithers.map (\t -> Format.HostOverrideLocal) (ExtractModel.decodeUnit cx input))), + (Model.Name "version", (\input -> Eithers.map (\t -> Format.HostOverrideVersion t) (Packaging.version cx input)))] + in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [ + "no such field ", + (Model.unName fname), + " in union"]))) (\f -> f fterm)) + _ -> Left (Errors.DecodingError "expected union")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.InputDigest +inputDigest :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.InputDigest +inputDigest cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "digestFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralInteger v2 -> case v2 of + Model.IntegerValueInt32 v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected int32 value") + _ -> Left (Errors.DecodingError "expected int32 literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_digestFormatVersion -> Eithers.bind (ExtractModel.requireField "moduleFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralInteger v2 -> case v2 of + Model.IntegerValueInt32 v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected int32 value") + _ -> Left (Errors.DecodingError "expected int32 literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_moduleFormatVersion -> Eithers.bind (ExtractModel.requireField "selfHash" (ExtractModel.decodeMaybe sha256Hash) fieldMap cx) (\field_selfHash -> Eithers.bind (ExtractModel.requireField "dependencyHashes" (ExtractModel.decodeMap Packaging.packageName sha256Hash) fieldMap cx) (\field_dependencyHashes -> Eithers.bind (ExtractModel.requireField "moduleHashes" (ExtractModel.decodeMap Packaging.moduleName sha256Hash) fieldMap cx) (\field_moduleHashes -> Right (Format.InputDigest { + Format.inputDigestDigestFormatVersion = field_digestFormatVersion, + Format.inputDigestModuleFormatVersion = field_moduleFormatVersion, + Format.inputDigestSelfHash = field_selfHash, + Format.inputDigestDependencyHashes = field_dependencyHashes, + Format.inputDigestModuleHashes = field_moduleHashes}))))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.InputDigest")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.LanguageName +languageName :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.LanguageName +languageName cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermWrap v0 -> Eithers.map (\b -> Format.LanguageName b) ((\raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx raw2)) (Model.wrappedTermBody v0)) + _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.LanguageProfile +languageProfile :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.LanguageProfile +languageProfile cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "name" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_name -> Eithers.bind (ExtractModel.requireField "coderPackage" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_coderPackage -> Eithers.bind (ExtractModel.requireField "family" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_family -> Right (Format.LanguageProfile { + Format.languageProfileName = field_name, + Format.languageProfileCoderPackage = field_coderPackage, + Format.languageProfileFamily = field_family}))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.LanguageProfile")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.ModuleValidationProfile +moduleValidationProfile :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.ModuleValidationProfile +moduleValidationProfile cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "definitions" (ExtractModel.decodeMaybe definitionValidationProfile) fieldMap cx) (\field_definitions -> Eithers.bind (ExtractModel.requireField "nameConvention" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_nameConvention -> Eithers.bind (ExtractModel.requireField "conflictingVariantName" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_conflictingVariantName -> Right (Format.ModuleValidationProfile { + Format.moduleValidationProfileDefinitions = field_definitions, + Format.moduleValidationProfileNameConvention = field_nameConvention, + Format.moduleValidationProfileConflictingVariantName = field_conflictingVariantName}))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.ModuleValidationProfile")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.OutputDigest +outputDigest :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.OutputDigest +outputDigest cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "digestFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralInteger v2 -> case v2 of + Model.IntegerValueInt32 v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected int32 value") + _ -> Left (Errors.DecodingError "expected int32 literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_digestFormatVersion -> Eithers.bind (ExtractModel.requireField "moduleFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralInteger v2 -> case v2 of + Model.IntegerValueInt32 v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected int32 value") + _ -> Left (Errors.DecodingError "expected int32 literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_moduleFormatVersion -> Eithers.bind (ExtractModel.requireField "generator" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_generator -> Eithers.bind (ExtractModel.requireField "generation" generation fieldMap cx) (\field_generation -> Eithers.bind (ExtractModel.requireField "selfHash" (ExtractModel.decodeMaybe sha256Hash) fieldMap cx) (\field_selfHash -> Eithers.bind (ExtractModel.requireField "dependencyHashes" (ExtractModel.decodeMap Packaging.packageName sha256Hash) fieldMap cx) (\field_dependencyHashes -> Eithers.bind (ExtractModel.requireField "inputs" (ExtractModel.decodeMap (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) digestEntry) fieldMap cx) (\field_inputs -> Eithers.bind (ExtractModel.requireField "outputs" (ExtractModel.decodeMap (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) digestEntry) fieldMap cx) (\field_outputs -> Right (Format.OutputDigest { + Format.outputDigestDigestFormatVersion = field_digestFormatVersion, + Format.outputDigestModuleFormatVersion = field_moduleFormatVersion, + Format.outputDigestGenerator = field_generator, + Format.outputDigestGeneration = field_generation, + Format.outputDigestSelfHash = field_selfHash, + Format.outputDigestDependencyHashes = field_dependencyHashes, + Format.outputDigestInputs = field_inputs, + Format.outputDigestOutputs = field_outputs})))))))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.OutputDigest")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.PackageDescriptor +packageDescriptor :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.PackageDescriptor +packageDescriptor cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "packageFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralInteger v2 -> case v2 of + Model.IntegerValueInt32 v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected int32 value") + _ -> Left (Errors.DecodingError "expected int32 literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_packageFormatVersion -> Eithers.bind (ExtractModel.requireField "name" Packaging.packageName fieldMap cx) (\field_name -> Eithers.bind (ExtractModel.requireField "description" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_description -> Eithers.bind (ExtractModel.requireField "sourceLanguage" languageName fieldMap cx) (\field_sourceLanguage -> Eithers.bind (ExtractModel.requireField "targetLanguages" (ExtractModel.decodeMaybe (ExtractModel.decodeList languageName)) fieldMap cx) (\field_targetLanguages -> Eithers.bind (ExtractModel.requireField "dependencies" (ExtractModel.decodeList Packaging.packageName) fieldMap cx) (\field_dependencies -> Eithers.bind (ExtractModel.requireField "validation" (ExtractModel.decodeMaybe packageValidationConfiguration) fieldMap cx) (\field_validation -> Right (Format.PackageDescriptor { + Format.packageDescriptorPackageFormatVersion = field_packageFormatVersion, + Format.packageDescriptorName = field_name, + Format.packageDescriptorDescription = field_description, + Format.packageDescriptorSourceLanguage = field_sourceLanguage, + Format.packageDescriptorTargetLanguages = field_targetLanguages, + Format.packageDescriptorDependencies = field_dependencies, + Format.packageDescriptorValidation = field_validation}))))))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.PackageDescriptor")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.PackageManifest +packageManifest :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.PackageManifest +packageManifest cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "manifestFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralInteger v2 -> case v2 of + Model.IntegerValueInt32 v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected int32 value") + _ -> Left (Errors.DecodingError "expected int32 literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_manifestFormatVersion -> Eithers.bind (ExtractModel.requireField "moduleFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralInteger v2 -> case v2 of + Model.IntegerValueInt32 v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected int32 value") + _ -> Left (Errors.DecodingError "expected int32 literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_moduleFormatVersion -> Eithers.bind (ExtractModel.requireField "package" Packaging.packageName fieldMap cx) (\field_package -> Eithers.bind (ExtractModel.requireField "mainModules" (ExtractModel.decodeList Packaging.moduleName) fieldMap cx) (\field_mainModules -> Eithers.bind (ExtractModel.requireField "testModules" (ExtractModel.decodeList Packaging.moduleName) fieldMap cx) (\field_testModules -> Eithers.bind (ExtractModel.requireField "mainDslModules" (ExtractModel.decodeList Packaging.moduleName) fieldMap cx) (\field_mainDslModules -> Eithers.bind (ExtractModel.requireField "mainEncodingModules" (ExtractModel.decodeList Packaging.moduleName) fieldMap cx) (\field_mainEncodingModules -> Right (Format.PackageManifest { + Format.packageManifestManifestFormatVersion = field_manifestFormatVersion, + Format.packageManifestModuleFormatVersion = field_moduleFormatVersion, + Format.packageManifestPackage = field_package, + Format.packageManifestMainModules = field_mainModules, + Format.packageManifestTestModules = field_testModules, + Format.packageManifestMainDslModules = field_mainDslModules, + Format.packageManifestMainEncodingModules = field_mainEncodingModules}))))))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.PackageManifest")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.PackageValidationConfiguration +packageValidationConfiguration :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.PackageValidationConfiguration +packageValidationConfiguration cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "package" (ExtractModel.decodeMaybe packageValidationProfile) fieldMap cx) (\field_package -> Eithers.bind (ExtractModel.requireField "module" (ExtractModel.decodeMaybe moduleValidationProfile) fieldMap cx) (\field_module -> Eithers.bind (ExtractModel.requireField "type" (ExtractModel.decodeMaybe typeValidationProfile) fieldMap cx) (\field_type -> Eithers.bind (ExtractModel.requireField "term" (ExtractModel.decodeMaybe termValidationProfile) fieldMap cx) (\field_term -> Right (Format.PackageValidationConfiguration { + Format.packageValidationConfigurationPackage = field_package, + Format.packageValidationConfigurationModule = field_module, + Format.packageValidationConfigurationType = field_type, + Format.packageValidationConfigurationTerm = field_term})))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.PackageValidationConfiguration")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.PackageValidationProfile +packageValidationProfile :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.PackageValidationProfile +packageValidationProfile cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "conflictingModuleName" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_conflictingModuleName -> Eithers.bind (ExtractModel.requireField "duplicateModuleName" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_duplicateModuleName -> Eithers.bind (ExtractModel.requireField "nameConvention" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_nameConvention -> Right (Format.PackageValidationProfile { + Format.packageValidationProfileConflictingModuleName = field_conflictingModuleName, + Format.packageValidationProfileDuplicateModuleName = field_duplicateModuleName, + Format.packageValidationProfileNameConvention = field_nameConvention}))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.PackageValidationProfile")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.RepositoryDescriptor +repositoryDescriptor :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.RepositoryDescriptor +repositoryDescriptor cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "currentVersion" Packaging.version fieldMap cx) (\field_currentVersion -> Eithers.bind (ExtractModel.requireField "hostVersion" Packaging.version fieldMap cx) (\field_hostVersion -> Eithers.bind (ExtractModel.requireField "hostOverrides" (ExtractModel.decodeMap languageName hostOverride) fieldMap cx) (\field_hostOverrides -> Eithers.bind (ExtractModel.requireField "group" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_group -> Eithers.bind (ExtractModel.requireField "author" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_author -> Eithers.bind (ExtractModel.requireField "url" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_url -> Eithers.bind (ExtractModel.requireField "license" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_license -> Eithers.bind (ExtractModel.requireField "packages" (ExtractModel.decodeList Packaging.packageName) fieldMap cx) (\field_packages -> Right (Format.RepositoryDescriptor { + Format.repositoryDescriptorCurrentVersion = field_currentVersion, + Format.repositoryDescriptorHostVersion = field_hostVersion, + Format.repositoryDescriptorHostOverrides = field_hostOverrides, + Format.repositoryDescriptorGroup = field_group, + Format.repositoryDescriptorAuthor = field_author, + Format.repositoryDescriptorUrl = field_url, + Format.repositoryDescriptorLicense = field_license, + Format.repositoryDescriptorPackages = field_packages})))))))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.RepositoryDescriptor")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.Severity +severity :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.Severity +severity cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermInject v0 -> + let field = Model.injectionField v0 + fname = Model.fieldName field + fterm = Model.fieldTerm field + variantMap = + Maps.fromList [ + (Model.Name "error", (\input -> Eithers.map (\t -> Format.SeverityError) (ExtractModel.decodeUnit cx input))), + (Model.Name "warning", (\input -> Eithers.map (\t -> Format.SeverityWarning) (ExtractModel.decodeUnit cx input)))] + in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [ + "no such field ", + (Model.unName fname), + " in union"]))) (\f -> f fterm)) + _ -> Left (Errors.DecodingError "expected union")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.Sha256Hash +sha256Hash :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.Sha256Hash +sha256Hash cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermWrap v0 -> Eithers.map (\b -> Format.Sha256Hash b) ((\raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Model.TermLiteral v1 -> case v1 of + Model.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx raw2)) (Model.wrappedTermBody v0)) + _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.TermValidationProfile +termValidationProfile :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.TermValidationProfile +termValidationProfile cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "duplicateBinding" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_duplicateBinding -> Eithers.bind (ExtractModel.requireField "emptyTermAnnotation" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_emptyTermAnnotation -> Eithers.bind (ExtractModel.requireField "undefinedVariable" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_undefinedVariable -> Right (Format.TermValidationProfile { + Format.termValidationProfileDuplicateBinding = field_duplicateBinding, + Format.termValidationProfileEmptyTermAnnotation = field_emptyTermAnnotation, + Format.termValidationProfileUndefinedVariable = field_undefinedVariable}))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.TermValidationProfile")) (ExtractModel.stripWithDecodingError cx raw) + +-- | Decoder for hydra.build.format.TypeValidationProfile +typeValidationProfile :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.TypeValidationProfile +typeValidationProfile cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Model.TermRecord v0 -> + let fieldMap = ExtractModel.toFieldMap v0 + in (Eithers.bind (ExtractModel.requireField "emptyAnnotation" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_emptyAnnotation -> Eithers.bind (ExtractModel.requireField "duplicateField" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_duplicateField -> Eithers.bind (ExtractModel.requireField "singleVariantUnion" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_singleVariantUnion -> Right (Format.TypeValidationProfile { + Format.typeValidationProfileEmptyAnnotation = field_emptyAnnotation, + Format.typeValidationProfileDuplicateField = field_duplicateField, + Format.typeValidationProfileSingleVariantUnion = field_singleVariantUnion}))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.TypeValidationProfile")) (ExtractModel.stripWithDecodingError cx raw) diff --git a/src/main/haskell/Hydra/Build/Dsl/Assembly.hs b/src/main/haskell/Hydra/Build/Dsl/Assembly.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Build/Dsl/Assembly.hs @@ -0,0 +1,375 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.build.assembly + +module Hydra.Build.Dsl.Assembly where + +import qualified Hydra.Build.Assembly as Assembly +import qualified Hydra.Build.Decode.Assembly as DecodeAssembly +import qualified Hydra.Build.Encode.Assembly as EncodeAssembly +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | DSL constructor for hydra.build.assembly.AssemblyEntry +assemblyEntry :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Assembly.AssemblyEntryKind -> Typed.TypedTerm [String] -> Typed.TypedTerm Assembly.AssemblyEntry +assemblyEntry sourceTree destTree kind exclude = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "sourceTree"), + Model.fieldTerm = (Typed.unTypedTerm sourceTree)}, + Model.Field { + Model.fieldName = (Model.Name "destTree"), + Model.fieldTerm = (Typed.unTypedTerm destTree)}, + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Typed.unTypedTerm kind)}, + Model.Field { + Model.fieldName = (Model.Name "exclude"), + Model.fieldTerm = (Typed.unTypedTerm exclude)}]})) + +-- | DSL name token for hydra.build.assembly.AssemblyEntry +assemblyEntryAssemblyEntry :: Typed.TypedName Assembly.AssemblyEntry +assemblyEntryAssemblyEntry = Typed.TypedName (Model.Name "hydra.build.assembly.AssemblyEntry") + +-- | DSL accessor for the destTree field of hydra.build.assembly.AssemblyEntry +assemblyEntryDestTree :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm String +assemblyEntryDestTree x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.projectionFieldName = (Model.Name "destTree")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the exclude field of hydra.build.assembly.AssemblyEntry +assemblyEntryExclude :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm [String] +assemblyEntryExclude x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.projectionFieldName = (Model.Name "exclude")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the kind field of hydra.build.assembly.AssemblyEntry +assemblyEntryKind :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm Assembly.AssemblyEntryKind +assemblyEntryKind x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.build.assembly.AssemblyEntryKind +assemblyEntryKindAssemblyEntryKind :: Typed.TypedName Assembly.AssemblyEntryKind +assemblyEntryKindAssemblyEntryKind = Typed.TypedName (Model.Name "hydra.build.assembly.AssemblyEntryKind") + +-- | DSL injection for the merge variant of hydra.build.assembly.AssemblyEntryKind +assemblyEntryKindMerge :: Typed.TypedTerm Assembly.AssemblyEntryKind +assemblyEntryKindMerge = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntryKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "merge"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the symlinkDir variant of hydra.build.assembly.AssemblyEntryKind +assemblyEntryKindSymlinkDir :: Typed.TypedTerm Assembly.AssemblyEntryKind +assemblyEntryKindSymlinkDir = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntryKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "symlinkDir"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the symlinkTree variant of hydra.build.assembly.AssemblyEntryKind +assemblyEntryKindSymlinkTree :: Typed.TypedTerm Assembly.AssemblyEntryKind +assemblyEntryKindSymlinkTree = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntryKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "symlinkTree"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the wipeThenCopy variant of hydra.build.assembly.AssemblyEntryKind +assemblyEntryKindWipeThenCopy :: Typed.TypedTerm Assembly.AssemblyEntryKind +assemblyEntryKindWipeThenCopy = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntryKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "wipeThenCopy"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL accessor for the sourceTree field of hydra.build.assembly.AssemblyEntry +assemblyEntrySourceTree :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm String +assemblyEntrySourceTree x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.projectionFieldName = (Model.Name "sourceTree")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the destTree field of hydra.build.assembly.AssemblyEntry +assemblyEntryWithDestTree :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm String -> Typed.TypedTerm Assembly.AssemblyEntry +assemblyEntryWithDestTree original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "sourceTree"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.projectionFieldName = (Model.Name "sourceTree")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "destTree"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "exclude"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.projectionFieldName = (Model.Name "exclude")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the exclude field of hydra.build.assembly.AssemblyEntry +assemblyEntryWithExclude :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm [String] -> Typed.TypedTerm Assembly.AssemblyEntry +assemblyEntryWithExclude original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "sourceTree"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.projectionFieldName = (Model.Name "sourceTree")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "destTree"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.projectionFieldName = (Model.Name "destTree")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "exclude"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the kind field of hydra.build.assembly.AssemblyEntry +assemblyEntryWithKind :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm Assembly.AssemblyEntryKind -> Typed.TypedTerm Assembly.AssemblyEntry +assemblyEntryWithKind original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "sourceTree"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.projectionFieldName = (Model.Name "sourceTree")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "destTree"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.projectionFieldName = (Model.Name "destTree")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "exclude"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.projectionFieldName = (Model.Name "exclude")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the sourceTree field of hydra.build.assembly.AssemblyEntry +assemblyEntryWithSourceTree :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm String -> Typed.TypedTerm Assembly.AssemblyEntry +assemblyEntryWithSourceTree original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "sourceTree"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "destTree"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.projectionFieldName = (Model.Name "destTree")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "exclude"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.projectionFieldName = (Model.Name "exclude")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.build.assembly.AssemblyPlan +assemblyPlan :: Typed.TypedTerm [Assembly.AssemblyEntry] -> Typed.TypedTerm [Assembly.KeepPathEntry] -> Typed.TypedTerm Assembly.AssemblyPlan +assemblyPlan entries keepPaths = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyPlan"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "entries"), + Model.fieldTerm = (Typed.unTypedTerm entries)}, + Model.Field { + Model.fieldName = (Model.Name "keepPaths"), + Model.fieldTerm = (Typed.unTypedTerm keepPaths)}]})) + +-- | DSL name token for hydra.build.assembly.AssemblyPlan +assemblyPlanAssemblyPlan :: Typed.TypedName Assembly.AssemblyPlan +assemblyPlanAssemblyPlan = Typed.TypedName (Model.Name "hydra.build.assembly.AssemblyPlan") + +-- | DSL accessor for the entries field of hydra.build.assembly.AssemblyPlan +assemblyPlanEntries :: Typed.TypedTerm Assembly.AssemblyPlan -> Typed.TypedTerm [Assembly.AssemblyEntry] +assemblyPlanEntries x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyPlan"), + Model.projectionFieldName = (Model.Name "entries")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the keepPaths field of hydra.build.assembly.AssemblyPlan +assemblyPlanKeepPaths :: Typed.TypedTerm Assembly.AssemblyPlan -> Typed.TypedTerm [Assembly.KeepPathEntry] +assemblyPlanKeepPaths x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyPlan"), + Model.projectionFieldName = (Model.Name "keepPaths")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the entries field of hydra.build.assembly.AssemblyPlan +assemblyPlanWithEntries :: Typed.TypedTerm Assembly.AssemblyPlan -> Typed.TypedTerm [Assembly.AssemblyEntry] -> Typed.TypedTerm Assembly.AssemblyPlan +assemblyPlanWithEntries original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyPlan"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "entries"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "keepPaths"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyPlan"), + Model.projectionFieldName = (Model.Name "keepPaths")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the keepPaths field of hydra.build.assembly.AssemblyPlan +assemblyPlanWithKeepPaths :: Typed.TypedTerm Assembly.AssemblyPlan -> Typed.TypedTerm [Assembly.KeepPathEntry] -> Typed.TypedTerm Assembly.AssemblyPlan +assemblyPlanWithKeepPaths original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyPlan"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "entries"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyPlan"), + Model.projectionFieldName = (Model.Name "entries")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "keepPaths"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.build.assembly.KeepPathEntry +keepPathEntry :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Assembly.KeepPathEntry +keepPathEntry sourceSetDir relPath = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.assembly.KeepPathEntry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "sourceSetDir"), + Model.fieldTerm = (Typed.unTypedTerm sourceSetDir)}, + Model.Field { + Model.fieldName = (Model.Name "relPath"), + Model.fieldTerm = (Typed.unTypedTerm relPath)}]})) + +-- | DSL name token for hydra.build.assembly.KeepPathEntry +keepPathEntryKeepPathEntry :: Typed.TypedName Assembly.KeepPathEntry +keepPathEntryKeepPathEntry = Typed.TypedName (Model.Name "hydra.build.assembly.KeepPathEntry") + +-- | DSL accessor for the relPath field of hydra.build.assembly.KeepPathEntry +keepPathEntryRelPath :: Typed.TypedTerm Assembly.KeepPathEntry -> Typed.TypedTerm String +keepPathEntryRelPath x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.KeepPathEntry"), + Model.projectionFieldName = (Model.Name "relPath")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the sourceSetDir field of hydra.build.assembly.KeepPathEntry +keepPathEntrySourceSetDir :: Typed.TypedTerm Assembly.KeepPathEntry -> Typed.TypedTerm String +keepPathEntrySourceSetDir x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.KeepPathEntry"), + Model.projectionFieldName = (Model.Name "sourceSetDir")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the relPath field of hydra.build.assembly.KeepPathEntry +keepPathEntryWithRelPath :: Typed.TypedTerm Assembly.KeepPathEntry -> Typed.TypedTerm String -> Typed.TypedTerm Assembly.KeepPathEntry +keepPathEntryWithRelPath original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.assembly.KeepPathEntry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "sourceSetDir"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.KeepPathEntry"), + Model.projectionFieldName = (Model.Name "sourceSetDir")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "relPath"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the sourceSetDir field of hydra.build.assembly.KeepPathEntry +keepPathEntryWithSourceSetDir :: Typed.TypedTerm Assembly.KeepPathEntry -> Typed.TypedTerm String -> Typed.TypedTerm Assembly.KeepPathEntry +keepPathEntryWithSourceSetDir original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.assembly.KeepPathEntry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "sourceSetDir"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "relPath"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.assembly.KeepPathEntry"), + Model.projectionFieldName = (Model.Name "relPath")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) diff --git a/src/main/haskell/Hydra/Build/Dsl/Benchresult.hs b/src/main/haskell/Hydra/Build/Dsl/Benchresult.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Build/Dsl/Benchresult.hs @@ -0,0 +1,597 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.build.benchresult + +module Hydra.Build.Dsl.Benchresult where + +import qualified Hydra.Build.Benchresult as Benchresult +import qualified Hydra.Build.Decode.Benchresult as DecodeBenchresult +import qualified Hydra.Build.Encode.Benchresult as EncodeBenchresult +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | DSL constructor for hydra.build.benchresult.BenchMetadata +benchMetadata :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.BenchMetadata +benchMetadata timestamp language branch commit commitMessage = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "timestamp"), + Model.fieldTerm = (Typed.unTypedTerm timestamp)}, + Model.Field { + Model.fieldName = (Model.Name "language"), + Model.fieldTerm = (Typed.unTypedTerm language)}, + Model.Field { + Model.fieldName = (Model.Name "branch"), + Model.fieldTerm = (Typed.unTypedTerm branch)}, + Model.Field { + Model.fieldName = (Model.Name "commit"), + Model.fieldTerm = (Typed.unTypedTerm commit)}, + Model.Field { + Model.fieldName = (Model.Name "commitMessage"), + Model.fieldTerm = (Typed.unTypedTerm commitMessage)}]})) + +-- | DSL name token for hydra.build.benchresult.BenchMetadata +benchMetadataBenchMetadata :: Typed.TypedName Benchresult.BenchMetadata +benchMetadataBenchMetadata = Typed.TypedName (Model.Name "hydra.build.benchresult.BenchMetadata") + +-- | DSL accessor for the branch field of hydra.build.benchresult.BenchMetadata +benchMetadataBranch :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String +benchMetadataBranch x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "branch")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the commit field of hydra.build.benchresult.BenchMetadata +benchMetadataCommit :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String +benchMetadataCommit x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "commit")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the commitMessage field of hydra.build.benchresult.BenchMetadata +benchMetadataCommitMessage :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String +benchMetadataCommitMessage x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "commitMessage")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the language field of hydra.build.benchresult.BenchMetadata +benchMetadataLanguage :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String +benchMetadataLanguage x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "language")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the timestamp field of hydra.build.benchresult.BenchMetadata +benchMetadataTimestamp :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String +benchMetadataTimestamp x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "timestamp")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the branch field of hydra.build.benchresult.BenchMetadata +benchMetadataWithBranch :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.BenchMetadata +benchMetadataWithBranch original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "timestamp"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "timestamp")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "language"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "language")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "branch"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "commit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "commit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "commitMessage"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "commitMessage")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the commit field of hydra.build.benchresult.BenchMetadata +benchMetadataWithCommit :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.BenchMetadata +benchMetadataWithCommit original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "timestamp"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "timestamp")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "language"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "language")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "branch"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "branch")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "commit"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "commitMessage"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "commitMessage")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the commitMessage field of hydra.build.benchresult.BenchMetadata +benchMetadataWithCommitMessage :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.BenchMetadata +benchMetadataWithCommitMessage original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "timestamp"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "timestamp")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "language"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "language")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "branch"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "branch")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "commit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "commit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "commitMessage"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the language field of hydra.build.benchresult.BenchMetadata +benchMetadataWithLanguage :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.BenchMetadata +benchMetadataWithLanguage original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "timestamp"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "timestamp")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "language"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "branch"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "branch")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "commit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "commit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "commitMessage"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "commitMessage")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the timestamp field of hydra.build.benchresult.BenchMetadata +benchMetadataWithTimestamp :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.BenchMetadata +benchMetadataWithTimestamp original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "timestamp"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "language"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "language")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "branch"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "branch")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "commit"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "commit")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "commitMessage"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.projectionFieldName = (Model.Name "commitMessage")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.build.benchresult.GenBenchResult +genBenchResult :: Typed.TypedTerm String -> Typed.TypedTerm Int -> Typed.TypedTerm (M.Map String Benchresult.HostResult) -> Typed.TypedTerm (Maybe Benchresult.BenchMetadata) -> Typed.TypedTerm Benchresult.GenBenchResult +genBenchResult target runs hosts metadata = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Typed.unTypedTerm target)}, + Model.Field { + Model.fieldName = (Model.Name "runs"), + Model.fieldTerm = (Typed.unTypedTerm runs)}, + Model.Field { + Model.fieldName = (Model.Name "hosts"), + Model.fieldTerm = (Typed.unTypedTerm hosts)}, + Model.Field { + Model.fieldName = (Model.Name "metadata"), + Model.fieldTerm = (Typed.unTypedTerm metadata)}]})) + +-- | DSL name token for hydra.build.benchresult.GenBenchResult +genBenchResultGenBenchResult :: Typed.TypedName Benchresult.GenBenchResult +genBenchResultGenBenchResult = Typed.TypedName (Model.Name "hydra.build.benchresult.GenBenchResult") + +-- | DSL accessor for the hosts field of hydra.build.benchresult.GenBenchResult +genBenchResultHosts :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm (M.Map String Benchresult.HostResult) +genBenchResultHosts x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.projectionFieldName = (Model.Name "hosts")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the metadata field of hydra.build.benchresult.GenBenchResult +genBenchResultMetadata :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm (Maybe Benchresult.BenchMetadata) +genBenchResultMetadata x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.projectionFieldName = (Model.Name "metadata")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the runs field of hydra.build.benchresult.GenBenchResult +genBenchResultRuns :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm Int +genBenchResultRuns x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.projectionFieldName = (Model.Name "runs")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the target field of hydra.build.benchresult.GenBenchResult +genBenchResultTarget :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm String +genBenchResultTarget x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the hosts field of hydra.build.benchresult.GenBenchResult +genBenchResultWithHosts :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm (M.Map String Benchresult.HostResult) -> Typed.TypedTerm Benchresult.GenBenchResult +genBenchResultWithHosts original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "runs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.projectionFieldName = (Model.Name "runs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hosts"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "metadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.projectionFieldName = (Model.Name "metadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the metadata field of hydra.build.benchresult.GenBenchResult +genBenchResultWithMetadata :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm (Maybe Benchresult.BenchMetadata) -> Typed.TypedTerm Benchresult.GenBenchResult +genBenchResultWithMetadata original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "runs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.projectionFieldName = (Model.Name "runs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hosts"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.projectionFieldName = (Model.Name "hosts")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "metadata"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the runs field of hydra.build.benchresult.GenBenchResult +genBenchResultWithRuns :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm Int -> Typed.TypedTerm Benchresult.GenBenchResult +genBenchResultWithRuns original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.projectionFieldName = (Model.Name "target")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "runs"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "hosts"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.projectionFieldName = (Model.Name "hosts")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "metadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.projectionFieldName = (Model.Name "metadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the target field of hydra.build.benchresult.GenBenchResult +genBenchResultWithTarget :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.GenBenchResult +genBenchResultWithTarget original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "runs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.projectionFieldName = (Model.Name "runs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hosts"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.projectionFieldName = (Model.Name "hosts")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "metadata"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.projectionFieldName = (Model.Name "metadata")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.build.benchresult.HostResult +hostResult :: Typed.TypedTerm Int -> Typed.TypedTerm (M.Map String Benchresult.RunStats) -> Typed.TypedTerm Benchresult.HostResult +hostResult setupMs packages = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.HostResult"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "setupMs"), + Model.fieldTerm = (Typed.unTypedTerm setupMs)}, + Model.Field { + Model.fieldName = (Model.Name "packages"), + Model.fieldTerm = (Typed.unTypedTerm packages)}]})) + +-- | DSL name token for hydra.build.benchresult.HostResult +hostResultHostResult :: Typed.TypedName Benchresult.HostResult +hostResultHostResult = Typed.TypedName (Model.Name "hydra.build.benchresult.HostResult") + +-- | DSL accessor for the packages field of hydra.build.benchresult.HostResult +hostResultPackages :: Typed.TypedTerm Benchresult.HostResult -> Typed.TypedTerm (M.Map String Benchresult.RunStats) +hostResultPackages x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.HostResult"), + Model.projectionFieldName = (Model.Name "packages")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the setupMs field of hydra.build.benchresult.HostResult +hostResultSetupMs :: Typed.TypedTerm Benchresult.HostResult -> Typed.TypedTerm Int +hostResultSetupMs x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.HostResult"), + Model.projectionFieldName = (Model.Name "setupMs")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the packages field of hydra.build.benchresult.HostResult +hostResultWithPackages :: Typed.TypedTerm Benchresult.HostResult -> Typed.TypedTerm (M.Map String Benchresult.RunStats) -> Typed.TypedTerm Benchresult.HostResult +hostResultWithPackages original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.HostResult"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "setupMs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.HostResult"), + Model.projectionFieldName = (Model.Name "setupMs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "packages"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the setupMs field of hydra.build.benchresult.HostResult +hostResultWithSetupMs :: Typed.TypedTerm Benchresult.HostResult -> Typed.TypedTerm Int -> Typed.TypedTerm Benchresult.HostResult +hostResultWithSetupMs original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.HostResult"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "setupMs"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "packages"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.HostResult"), + Model.projectionFieldName = (Model.Name "packages")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.build.benchresult.RunStats +runStats :: Typed.TypedTerm [Int] -> Typed.TypedTerm Int -> Typed.TypedTerm Benchresult.RunStats +runStats runsMs medianMs = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.RunStats"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "runsMs"), + Model.fieldTerm = (Typed.unTypedTerm runsMs)}, + Model.Field { + Model.fieldName = (Model.Name "medianMs"), + Model.fieldTerm = (Typed.unTypedTerm medianMs)}]})) + +-- | DSL accessor for the medianMs field of hydra.build.benchresult.RunStats +runStatsMedianMs :: Typed.TypedTerm Benchresult.RunStats -> Typed.TypedTerm Int +runStatsMedianMs x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.RunStats"), + Model.projectionFieldName = (Model.Name "medianMs")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.build.benchresult.RunStats +runStatsRunStats :: Typed.TypedName Benchresult.RunStats +runStatsRunStats = Typed.TypedName (Model.Name "hydra.build.benchresult.RunStats") + +-- | DSL accessor for the runsMs field of hydra.build.benchresult.RunStats +runStatsRunsMs :: Typed.TypedTerm Benchresult.RunStats -> Typed.TypedTerm [Int] +runStatsRunsMs x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.RunStats"), + Model.projectionFieldName = (Model.Name "runsMs")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the medianMs field of hydra.build.benchresult.RunStats +runStatsWithMedianMs :: Typed.TypedTerm Benchresult.RunStats -> Typed.TypedTerm Int -> Typed.TypedTerm Benchresult.RunStats +runStatsWithMedianMs original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.RunStats"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "runsMs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.RunStats"), + Model.projectionFieldName = (Model.Name "runsMs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "medianMs"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the runsMs field of hydra.build.benchresult.RunStats +runStatsWithRunsMs :: Typed.TypedTerm Benchresult.RunStats -> Typed.TypedTerm [Int] -> Typed.TypedTerm Benchresult.RunStats +runStatsWithRunsMs original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.RunStats"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "runsMs"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "medianMs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.benchresult.RunStats"), + Model.projectionFieldName = (Model.Name "medianMs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) diff --git a/src/main/haskell/Hydra/Build/Dsl/Comparereport.hs b/src/main/haskell/Hydra/Build/Dsl/Comparereport.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Build/Dsl/Comparereport.hs @@ -0,0 +1,425 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.build.comparereport + +module Hydra.Build.Dsl.Comparereport where + +import qualified Hydra.Build.Comparereport as Comparereport +import qualified Hydra.Build.Decode.Comparereport as DecodeComparereport +import qualified Hydra.Build.Encode.Comparereport as EncodeComparereport +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Typed as Typed +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | DSL constructor for hydra.build.comparereport.CompareReport +compareReport :: Typed.TypedTerm [Comparereport.ModuleCompare] -> Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.CompareReport +compareReport rows byteEqCount total = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.comparereport.CompareReport"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "rows"), + Model.fieldTerm = (Typed.unTypedTerm rows)}, + Model.Field { + Model.fieldName = (Model.Name "byteEqCount"), + Model.fieldTerm = (Typed.unTypedTerm byteEqCount)}, + Model.Field { + Model.fieldName = (Model.Name "total"), + Model.fieldTerm = (Typed.unTypedTerm total)}]})) + +-- | DSL accessor for the byteEqCount field of hydra.build.comparereport.CompareReport +compareReportByteEqCount :: Typed.TypedTerm Comparereport.CompareReport -> Typed.TypedTerm Int +compareReportByteEqCount x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.CompareReport"), + Model.projectionFieldName = (Model.Name "byteEqCount")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.build.comparereport.CompareReport +compareReportCompareReport :: Typed.TypedName Comparereport.CompareReport +compareReportCompareReport = Typed.TypedName (Model.Name "hydra.build.comparereport.CompareReport") + +-- | DSL accessor for the rows field of hydra.build.comparereport.CompareReport +compareReportRows :: Typed.TypedTerm Comparereport.CompareReport -> Typed.TypedTerm [Comparereport.ModuleCompare] +compareReportRows x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.CompareReport"), + Model.projectionFieldName = (Model.Name "rows")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the total field of hydra.build.comparereport.CompareReport +compareReportTotal :: Typed.TypedTerm Comparereport.CompareReport -> Typed.TypedTerm Int +compareReportTotal x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.CompareReport"), + Model.projectionFieldName = (Model.Name "total")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the byteEqCount field of hydra.build.comparereport.CompareReport +compareReportWithByteEqCount :: Typed.TypedTerm Comparereport.CompareReport -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.CompareReport +compareReportWithByteEqCount original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.comparereport.CompareReport"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "rows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.CompareReport"), + Model.projectionFieldName = (Model.Name "rows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "byteEqCount"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "total"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.CompareReport"), + Model.projectionFieldName = (Model.Name "total")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the rows field of hydra.build.comparereport.CompareReport +compareReportWithRows :: Typed.TypedTerm Comparereport.CompareReport -> Typed.TypedTerm [Comparereport.ModuleCompare] -> Typed.TypedTerm Comparereport.CompareReport +compareReportWithRows original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.comparereport.CompareReport"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "rows"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "byteEqCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.CompareReport"), + Model.projectionFieldName = (Model.Name "byteEqCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "total"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.CompareReport"), + Model.projectionFieldName = (Model.Name "total")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the total field of hydra.build.comparereport.CompareReport +compareReportWithTotal :: Typed.TypedTerm Comparereport.CompareReport -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.CompareReport +compareReportWithTotal original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.comparereport.CompareReport"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "rows"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.CompareReport"), + Model.projectionFieldName = (Model.Name "rows")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "byteEqCount"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.CompareReport"), + Model.projectionFieldName = (Model.Name "byteEqCount")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "total"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL injection for the byteEq variant of hydra.build.comparereport.CompareStatus +compareStatusByteEq :: Typed.TypedTerm Comparereport.CompareStatus +compareStatusByteEq = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.comparereport.CompareStatus"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "byteEq"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.build.comparereport.CompareStatus +compareStatusCompareStatus :: Typed.TypedName Comparereport.CompareStatus +compareStatusCompareStatus = Typed.TypedName (Model.Name "hydra.build.comparereport.CompareStatus") + +-- | DSL injection for the differ variant of hydra.build.comparereport.CompareStatus +compareStatusDiffer :: Typed.TypedTerm Comparereport.CompareStatus +compareStatusDiffer = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.comparereport.CompareStatus"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "differ"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the missing variant of hydra.build.comparereport.CompareStatus +compareStatusMissing :: Typed.TypedTerm Comparereport.CompareStatus +compareStatusMissing = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.comparereport.CompareStatus"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "missing"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.build.comparereport.ModuleCompare +moduleCompare :: Typed.TypedTerm String -> Typed.TypedTerm Comparereport.CompareStatus -> Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.ModuleCompare +moduleCompare module_ status ourSize canonSize diffLines = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "module"), + Model.fieldTerm = (Typed.unTypedTerm module_)}, + Model.Field { + Model.fieldName = (Model.Name "status"), + Model.fieldTerm = (Typed.unTypedTerm status)}, + Model.Field { + Model.fieldName = (Model.Name "ourSize"), + Model.fieldTerm = (Typed.unTypedTerm ourSize)}, + Model.Field { + Model.fieldName = (Model.Name "canonSize"), + Model.fieldTerm = (Typed.unTypedTerm canonSize)}, + Model.Field { + Model.fieldName = (Model.Name "diffLines"), + Model.fieldTerm = (Typed.unTypedTerm diffLines)}]})) + +-- | DSL accessor for the canonSize field of hydra.build.comparereport.ModuleCompare +moduleCompareCanonSize :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Int +moduleCompareCanonSize x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "canonSize")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the diffLines field of hydra.build.comparereport.ModuleCompare +moduleCompareDiffLines :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Int +moduleCompareDiffLines x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "diffLines")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the module field of hydra.build.comparereport.ModuleCompare +moduleCompareModule :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm String +moduleCompareModule x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "module")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.build.comparereport.ModuleCompare +moduleCompareModuleCompare :: Typed.TypedName Comparereport.ModuleCompare +moduleCompareModuleCompare = Typed.TypedName (Model.Name "hydra.build.comparereport.ModuleCompare") + +-- | DSL accessor for the ourSize field of hydra.build.comparereport.ModuleCompare +moduleCompareOurSize :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Int +moduleCompareOurSize x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "ourSize")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the status field of hydra.build.comparereport.ModuleCompare +moduleCompareStatus :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Comparereport.CompareStatus +moduleCompareStatus x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "status")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the canonSize field of hydra.build.comparereport.ModuleCompare +moduleCompareWithCanonSize :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.ModuleCompare +moduleCompareWithCanonSize original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "module"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "module")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "status"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "status")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ourSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "ourSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "canonSize"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "diffLines"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "diffLines")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the diffLines field of hydra.build.comparereport.ModuleCompare +moduleCompareWithDiffLines :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.ModuleCompare +moduleCompareWithDiffLines original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "module"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "module")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "status"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "status")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ourSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "ourSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "canonSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "canonSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "diffLines"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the module field of hydra.build.comparereport.ModuleCompare +moduleCompareWithModule :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm String -> Typed.TypedTerm Comparereport.ModuleCompare +moduleCompareWithModule original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "module"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "status"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "status")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ourSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "ourSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "canonSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "canonSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "diffLines"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "diffLines")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the ourSize field of hydra.build.comparereport.ModuleCompare +moduleCompareWithOurSize :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.ModuleCompare +moduleCompareWithOurSize original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "module"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "module")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "status"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "status")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ourSize"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "canonSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "canonSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "diffLines"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "diffLines")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the status field of hydra.build.comparereport.ModuleCompare +moduleCompareWithStatus :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Comparereport.CompareStatus -> Typed.TypedTerm Comparereport.ModuleCompare +moduleCompareWithStatus original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "module"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "module")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "status"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ourSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "ourSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "canonSize"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "canonSize")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "diffLines"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.projectionFieldName = (Model.Name "diffLines")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) diff --git a/src/main/haskell/Hydra/Build/Dsl/Format.hs b/src/main/haskell/Hydra/Build/Dsl/Format.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Build/Dsl/Format.hs @@ -0,0 +1,4108 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.build.format + +module Hydra.Build.Dsl.Format where + +import qualified Hydra.Build.Decode.Format as DecodeFormat +import qualified Hydra.Build.Encode.Format as EncodeFormat +import qualified Hydra.Build.Format as Format +import qualified Hydra.Core.Dsl.Packaging as DslPackaging +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Typed as Typed +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void +import qualified Data.Map as M + +-- | DSL constructor for hydra.build.format.DefinitionNameConventionProfile +definitionNameConventionProfile :: Typed.TypedTerm Format.Severity -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.DefinitionNameConventionProfile +definitionNameConventionProfile severity allowUnderscores = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionNameConventionProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Typed.unTypedTerm severity)}, + Model.Field { + Model.fieldName = (Model.Name "allowUnderscores"), + Model.fieldTerm = (Typed.unTypedTerm allowUnderscores)}]})) + +-- | DSL accessor for the allowUnderscores field of hydra.build.format.DefinitionNameConventionProfile +definitionNameConventionProfileAllowUnderscores :: Typed.TypedTerm Format.DefinitionNameConventionProfile -> Typed.TypedTerm Bool +definitionNameConventionProfileAllowUnderscores x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionNameConventionProfile"), + Model.projectionFieldName = (Model.Name "allowUnderscores")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.build.format.DefinitionNameConventionProfile +definitionNameConventionProfileDefinitionNameConventionProfile :: Typed.TypedName Format.DefinitionNameConventionProfile +definitionNameConventionProfileDefinitionNameConventionProfile = + Typed.TypedName (Model.Name "hydra.build.format.DefinitionNameConventionProfile") + +-- | DSL accessor for the severity field of hydra.build.format.DefinitionNameConventionProfile +definitionNameConventionProfileSeverity :: Typed.TypedTerm Format.DefinitionNameConventionProfile -> Typed.TypedTerm Format.Severity +definitionNameConventionProfileSeverity x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionNameConventionProfile"), + Model.projectionFieldName = (Model.Name "severity")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the allowUnderscores field of hydra.build.format.DefinitionNameConventionProfile +definitionNameConventionProfileWithAllowUnderscores :: Typed.TypedTerm Format.DefinitionNameConventionProfile -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.DefinitionNameConventionProfile +definitionNameConventionProfileWithAllowUnderscores original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionNameConventionProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionNameConventionProfile"), + Model.projectionFieldName = (Model.Name "severity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "allowUnderscores"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the severity field of hydra.build.format.DefinitionNameConventionProfile +definitionNameConventionProfileWithSeverity :: Typed.TypedTerm Format.DefinitionNameConventionProfile -> Typed.TypedTerm Format.Severity -> Typed.TypedTerm Format.DefinitionNameConventionProfile +definitionNameConventionProfileWithSeverity original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionNameConventionProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "allowUnderscores"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionNameConventionProfile"), + Model.projectionFieldName = (Model.Name "allowUnderscores")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.build.format.DefinitionValidationProfile +definitionValidationProfile :: Typed.TypedTerm (Maybe Format.DocumentationProfile) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.DefinitionNameConventionProfile) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.DefinitionValidationProfile +definitionValidationProfile hasDescription ordering nameConvention notInModuleName duplicateName = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "hasDescription"), + Model.fieldTerm = (Typed.unTypedTerm hasDescription)}, + Model.Field { + Model.fieldName = (Model.Name "ordering"), + Model.fieldTerm = (Typed.unTypedTerm ordering)}, + Model.Field { + Model.fieldName = (Model.Name "nameConvention"), + Model.fieldTerm = (Typed.unTypedTerm nameConvention)}, + Model.Field { + Model.fieldName = (Model.Name "notInModuleName"), + Model.fieldTerm = (Typed.unTypedTerm notInModuleName)}, + Model.Field { + Model.fieldName = (Model.Name "duplicateName"), + Model.fieldTerm = (Typed.unTypedTerm duplicateName)}]})) + +-- | DSL name token for hydra.build.format.DefinitionValidationProfile +definitionValidationProfileDefinitionValidationProfile :: Typed.TypedName Format.DefinitionValidationProfile +definitionValidationProfileDefinitionValidationProfile = + Typed.TypedName (Model.Name "hydra.build.format.DefinitionValidationProfile") + +-- | DSL accessor for the duplicateName field of hydra.build.format.DefinitionValidationProfile +definitionValidationProfileDuplicateName :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) +definitionValidationProfileDuplicateName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "duplicateName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the hasDescription field of hydra.build.format.DefinitionValidationProfile +definitionValidationProfileHasDescription :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.DocumentationProfile) +definitionValidationProfileHasDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "hasDescription")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the nameConvention field of hydra.build.format.DefinitionValidationProfile +definitionValidationProfileNameConvention :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.DefinitionNameConventionProfile) +definitionValidationProfileNameConvention x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "nameConvention")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the notInModuleName field of hydra.build.format.DefinitionValidationProfile +definitionValidationProfileNotInModuleName :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) +definitionValidationProfileNotInModuleName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "notInModuleName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the ordering field of hydra.build.format.DefinitionValidationProfile +definitionValidationProfileOrdering :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) +definitionValidationProfileOrdering x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "ordering")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the duplicateName field of hydra.build.format.DefinitionValidationProfile +definitionValidationProfileWithDuplicateName :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.DefinitionValidationProfile +definitionValidationProfileWithDuplicateName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "hasDescription"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "hasDescription")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ordering"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "ordering")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "nameConvention"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "nameConvention")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "notInModuleName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "notInModuleName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "duplicateName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the hasDescription field of hydra.build.format.DefinitionValidationProfile +definitionValidationProfileWithHasDescription :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.DocumentationProfile) -> Typed.TypedTerm Format.DefinitionValidationProfile +definitionValidationProfileWithHasDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "hasDescription"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "ordering"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "ordering")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "nameConvention"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "nameConvention")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "notInModuleName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "notInModuleName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "duplicateName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "duplicateName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the nameConvention field of hydra.build.format.DefinitionValidationProfile +definitionValidationProfileWithNameConvention :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.DefinitionNameConventionProfile) -> Typed.TypedTerm Format.DefinitionValidationProfile +definitionValidationProfileWithNameConvention original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "hasDescription"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "hasDescription")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ordering"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "ordering")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "nameConvention"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "notInModuleName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "notInModuleName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "duplicateName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "duplicateName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the notInModuleName field of hydra.build.format.DefinitionValidationProfile +definitionValidationProfileWithNotInModuleName :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.DefinitionValidationProfile +definitionValidationProfileWithNotInModuleName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "hasDescription"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "hasDescription")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ordering"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "ordering")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "nameConvention"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "nameConvention")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "notInModuleName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "duplicateName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "duplicateName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the ordering field of hydra.build.format.DefinitionValidationProfile +definitionValidationProfileWithOrdering :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.DefinitionValidationProfile +definitionValidationProfileWithOrdering original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "hasDescription"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "hasDescription")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "ordering"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "nameConvention"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "nameConvention")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "notInModuleName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "notInModuleName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "duplicateName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.projectionFieldName = (Model.Name "duplicateName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.build.format.DigestEntry +digestEntry :: Typed.TypedTerm Format.DigestKind -> Typed.TypedTerm Format.Sha256Hash -> Typed.TypedTerm Format.DigestEntry +digestEntry kind hash = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.DigestEntry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Typed.unTypedTerm kind)}, + Model.Field { + Model.fieldName = (Model.Name "hash"), + Model.fieldTerm = (Typed.unTypedTerm hash)}]})) + +-- | DSL name token for hydra.build.format.DigestEntry +digestEntryDigestEntry :: Typed.TypedName Format.DigestEntry +digestEntryDigestEntry = Typed.TypedName (Model.Name "hydra.build.format.DigestEntry") + +-- | DSL accessor for the hash field of hydra.build.format.DigestEntry +digestEntryHash :: Typed.TypedTerm Format.DigestEntry -> Typed.TypedTerm Format.Sha256Hash +digestEntryHash x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DigestEntry"), + Model.projectionFieldName = (Model.Name "hash")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the kind field of hydra.build.format.DigestEntry +digestEntryKind :: Typed.TypedTerm Format.DigestEntry -> Typed.TypedTerm Format.DigestKind +digestEntryKind x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DigestEntry"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the hash field of hydra.build.format.DigestEntry +digestEntryWithHash :: Typed.TypedTerm Format.DigestEntry -> Typed.TypedTerm Format.Sha256Hash -> Typed.TypedTerm Format.DigestEntry +digestEntryWithHash original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.DigestEntry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DigestEntry"), + Model.projectionFieldName = (Model.Name "kind")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hash"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the kind field of hydra.build.format.DigestEntry +digestEntryWithKind :: Typed.TypedTerm Format.DigestEntry -> Typed.TypedTerm Format.DigestKind -> Typed.TypedTerm Format.DigestEntry +digestEntryWithKind original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.DigestEntry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "hash"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DigestEntry"), + Model.projectionFieldName = (Model.Name "hash")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.build.format.DigestKind +digestKindDigestKind :: Typed.TypedName Format.DigestKind +digestKindDigestKind = Typed.TypedName (Model.Name "hydra.build.format.DigestKind") + +-- | DSL injection for the dslSource variant of hydra.build.format.DigestKind +digestKindDslSource :: Typed.TypedTerm Format.DigestKind +digestKindDslSource = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.DigestKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "dslSource"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the jsonFile variant of hydra.build.format.DigestKind +digestKindJsonFile :: Typed.TypedTerm Format.DigestKind +digestKindJsonFile = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.DigestKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "jsonFile"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the other variant of hydra.build.format.DigestKind +digestKindOther :: Typed.TypedTerm Format.DigestKind +digestKindOther = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.DigestKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "other"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the runtimeFile variant of hydra.build.format.DigestKind +digestKindRuntimeFile :: Typed.TypedTerm Format.DigestKind +digestKindRuntimeFile = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.DigestKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "runtimeFile"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the targetFile variant of hydra.build.format.DigestKind +digestKindTargetFile :: Typed.TypedTerm Format.DigestKind +digestKindTargetFile = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.DigestKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "targetFile"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for hydra.build.format.DocumentationProfile +documentationProfile :: Typed.TypedTerm Format.Severity -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.DocumentationProfile +documentationProfile severity exemptDeprecated = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.DocumentationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Typed.unTypedTerm severity)}, + Model.Field { + Model.fieldName = (Model.Name "exemptDeprecated"), + Model.fieldTerm = (Typed.unTypedTerm exemptDeprecated)}]})) + +-- | DSL name token for hydra.build.format.DocumentationProfile +documentationProfileDocumentationProfile :: Typed.TypedName Format.DocumentationProfile +documentationProfileDocumentationProfile = Typed.TypedName (Model.Name "hydra.build.format.DocumentationProfile") + +-- | DSL accessor for the exemptDeprecated field of hydra.build.format.DocumentationProfile +documentationProfileExemptDeprecated :: Typed.TypedTerm Format.DocumentationProfile -> Typed.TypedTerm Bool +documentationProfileExemptDeprecated x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DocumentationProfile"), + Model.projectionFieldName = (Model.Name "exemptDeprecated")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the severity field of hydra.build.format.DocumentationProfile +documentationProfileSeverity :: Typed.TypedTerm Format.DocumentationProfile -> Typed.TypedTerm Format.Severity +documentationProfileSeverity x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DocumentationProfile"), + Model.projectionFieldName = (Model.Name "severity")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the exemptDeprecated field of hydra.build.format.DocumentationProfile +documentationProfileWithExemptDeprecated :: Typed.TypedTerm Format.DocumentationProfile -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.DocumentationProfile +documentationProfileWithExemptDeprecated original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.DocumentationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DocumentationProfile"), + Model.projectionFieldName = (Model.Name "severity")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "exemptDeprecated"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the severity field of hydra.build.format.DocumentationProfile +documentationProfileWithSeverity :: Typed.TypedTerm Format.DocumentationProfile -> Typed.TypedTerm Format.Severity -> Typed.TypedTerm Format.DocumentationProfile +documentationProfileWithSeverity original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.DocumentationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "exemptDeprecated"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.DocumentationProfile"), + Model.projectionFieldName = (Model.Name "exemptDeprecated")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.build.format.Generation +generation :: Typed.TypedTerm String -> Typed.TypedTerm Format.GenerationMode -> Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm (Maybe Packaging.Version) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.Generation +generation generatorId mode host hydraVersion revision timestamp = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.Generation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "generatorId"), + Model.fieldTerm = (Typed.unTypedTerm generatorId)}, + Model.Field { + Model.fieldName = (Model.Name "mode"), + Model.fieldTerm = (Typed.unTypedTerm mode)}, + Model.Field { + Model.fieldName = (Model.Name "host"), + Model.fieldTerm = (Typed.unTypedTerm host)}, + Model.Field { + Model.fieldName = (Model.Name "hydraVersion"), + Model.fieldTerm = (Typed.unTypedTerm hydraVersion)}, + Model.Field { + Model.fieldName = (Model.Name "revision"), + Model.fieldTerm = (Typed.unTypedTerm revision)}, + Model.Field { + Model.fieldName = (Model.Name "timestamp"), + Model.fieldTerm = (Typed.unTypedTerm timestamp)}]})) + +-- | DSL name token for hydra.build.format.Generation +generationGeneration :: Typed.TypedName Format.Generation +generationGeneration = Typed.TypedName (Model.Name "hydra.build.format.Generation") + +-- | DSL accessor for the generatorId field of hydra.build.format.Generation +generationGeneratorId :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm String +generationGeneratorId x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "generatorId")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the host field of hydra.build.format.Generation +generationHost :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.LanguageName +generationHost x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "host")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the hydraVersion field of hydra.build.format.Generation +generationHydraVersion :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe Packaging.Version) +generationHydraVersion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "hydraVersion")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the mode field of hydra.build.format.Generation +generationMode :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.GenerationMode +generationMode x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "mode")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.build.format.GenerationMode +generationModeGenerationMode :: Typed.TypedName Format.GenerationMode +generationModeGenerationMode = Typed.TypedName (Model.Name "hydra.build.format.GenerationMode") + +-- | DSL injection for the published variant of hydra.build.format.GenerationMode +generationModePublished :: Typed.TypedTerm Format.GenerationMode +generationModePublished = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.GenerationMode"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "published"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the shim variant of hydra.build.format.GenerationMode +generationModeShim :: Typed.TypedTerm Format.GenerationMode +generationModeShim = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.GenerationMode"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "shim"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL accessor for the revision field of hydra.build.format.Generation +generationRevision :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe String) +generationRevision x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "revision")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the timestamp field of hydra.build.format.Generation +generationTimestamp :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe String) +generationTimestamp x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "timestamp")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the generatorId field of hydra.build.format.Generation +generationWithGeneratorId :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm String -> Typed.TypedTerm Format.Generation +generationWithGeneratorId original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.Generation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "generatorId"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "mode"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "mode")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "host"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "host")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hydraVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "hydraVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "revision"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "revision")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "timestamp"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "timestamp")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the host field of hydra.build.format.Generation +generationWithHost :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm Format.Generation +generationWithHost original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.Generation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "generatorId"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "generatorId")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mode"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "mode")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "host"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "hydraVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "hydraVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "revision"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "revision")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "timestamp"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "timestamp")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the hydraVersion field of hydra.build.format.Generation +generationWithHydraVersion :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe Packaging.Version) -> Typed.TypedTerm Format.Generation +generationWithHydraVersion original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.Generation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "generatorId"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "generatorId")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mode"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "mode")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "host"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "host")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hydraVersion"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "revision"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "revision")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "timestamp"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "timestamp")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the mode field of hydra.build.format.Generation +generationWithMode :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.GenerationMode -> Typed.TypedTerm Format.Generation +generationWithMode original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.Generation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "generatorId"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "generatorId")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mode"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "host"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "host")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hydraVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "hydraVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "revision"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "revision")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "timestamp"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "timestamp")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the revision field of hydra.build.format.Generation +generationWithRevision :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.Generation +generationWithRevision original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.Generation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "generatorId"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "generatorId")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mode"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "mode")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "host"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "host")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hydraVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "hydraVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "revision"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "timestamp"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "timestamp")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the timestamp field of hydra.build.format.Generation +generationWithTimestamp :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.Generation +generationWithTimestamp original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.Generation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "generatorId"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "generatorId")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mode"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "mode")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "host"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "host")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hydraVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "hydraVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "revision"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"), + Model.projectionFieldName = (Model.Name "revision")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "timestamp"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL name token for hydra.build.format.HostOverride +hostOverrideHostOverride :: Typed.TypedName Format.HostOverride +hostOverrideHostOverride = Typed.TypedName (Model.Name "hydra.build.format.HostOverride") + +-- | DSL injection for the local variant of hydra.build.format.HostOverride +hostOverrideLocal :: Typed.TypedTerm Format.HostOverride +hostOverrideLocal = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.HostOverride"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "local"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL injection for the version variant of hydra.build.format.HostOverride +hostOverrideVersion :: Typed.TypedTerm Packaging.Version -> Typed.TypedTerm Format.HostOverride +hostOverrideVersion x = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.HostOverride"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL constructor for hydra.build.format.InputDigest +inputDigest :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm (Maybe Format.Sha256Hash) -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) -> Typed.TypedTerm (M.Map Packaging.ModuleName Format.Sha256Hash) -> Typed.TypedTerm Format.InputDigest +inputDigest digestFormatVersion moduleFormatVersion selfHash dependencyHashes moduleHashes = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "digestFormatVersion"), + Model.fieldTerm = (Typed.unTypedTerm digestFormatVersion)}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Typed.unTypedTerm moduleFormatVersion)}, + Model.Field { + Model.fieldName = (Model.Name "selfHash"), + Model.fieldTerm = (Typed.unTypedTerm selfHash)}, + Model.Field { + Model.fieldName = (Model.Name "dependencyHashes"), + Model.fieldTerm = (Typed.unTypedTerm dependencyHashes)}, + Model.Field { + Model.fieldName = (Model.Name "moduleHashes"), + Model.fieldTerm = (Typed.unTypedTerm moduleHashes)}]})) + +-- | DSL accessor for the dependencyHashes field of hydra.build.format.InputDigest +inputDigestDependencyHashes :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) +inputDigestDependencyHashes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "dependencyHashes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the digestFormatVersion field of hydra.build.format.InputDigest +inputDigestDigestFormatVersion :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm Int +inputDigestDigestFormatVersion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "digestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.build.format.InputDigest +inputDigestInputDigest :: Typed.TypedName Format.InputDigest +inputDigestInputDigest = Typed.TypedName (Model.Name "hydra.build.format.InputDigest") + +-- | DSL accessor for the moduleFormatVersion field of hydra.build.format.InputDigest +inputDigestModuleFormatVersion :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm Int +inputDigestModuleFormatVersion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the moduleHashes field of hydra.build.format.InputDigest +inputDigestModuleHashes :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (M.Map Packaging.ModuleName Format.Sha256Hash) +inputDigestModuleHashes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "moduleHashes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the selfHash field of hydra.build.format.InputDigest +inputDigestSelfHash :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (Maybe Format.Sha256Hash) +inputDigestSelfHash x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "selfHash")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the dependencyHashes field of hydra.build.format.InputDigest +inputDigestWithDependencyHashes :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) -> Typed.TypedTerm Format.InputDigest +inputDigestWithDependencyHashes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "digestFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "digestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "selfHash"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "selfHash")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependencyHashes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "moduleHashes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "moduleHashes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the digestFormatVersion field of hydra.build.format.InputDigest +inputDigestWithDigestFormatVersion :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.InputDigest +inputDigestWithDigestFormatVersion original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "digestFormatVersion"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "selfHash"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "selfHash")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependencyHashes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "dependencyHashes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleHashes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "moduleHashes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the moduleFormatVersion field of hydra.build.format.InputDigest +inputDigestWithModuleFormatVersion :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.InputDigest +inputDigestWithModuleFormatVersion original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "digestFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "digestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "selfHash"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "selfHash")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependencyHashes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "dependencyHashes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleHashes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "moduleHashes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the moduleHashes field of hydra.build.format.InputDigest +inputDigestWithModuleHashes :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (M.Map Packaging.ModuleName Format.Sha256Hash) -> Typed.TypedTerm Format.InputDigest +inputDigestWithModuleHashes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "digestFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "digestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "selfHash"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "selfHash")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependencyHashes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "dependencyHashes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleHashes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the selfHash field of hydra.build.format.InputDigest +inputDigestWithSelfHash :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (Maybe Format.Sha256Hash) -> Typed.TypedTerm Format.InputDigest +inputDigestWithSelfHash original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "digestFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "digestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "selfHash"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "dependencyHashes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "dependencyHashes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleHashes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.projectionFieldName = (Model.Name "moduleHashes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for the hydra.build.format.LanguageName wrapper +languageName :: Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageName +languageName x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.build.format.LanguageName"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.build.format.LanguageName +languageNameLanguageName :: Typed.TypedName Format.LanguageName +languageNameLanguageName = Typed.TypedName (Model.Name "hydra.build.format.LanguageName") + +-- | DSL constructor for hydra.build.format.LanguageProfile +languageProfile :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile +languageProfile name coderPackage family = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.LanguageProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "coderPackage"), + Model.fieldTerm = (Typed.unTypedTerm coderPackage)}, + Model.Field { + Model.fieldName = (Model.Name "family"), + Model.fieldTerm = (Typed.unTypedTerm family)}]})) + +-- | DSL accessor for the coderPackage field of hydra.build.format.LanguageProfile +languageProfileCoderPackage :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String +languageProfileCoderPackage x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.LanguageProfile"), + Model.projectionFieldName = (Model.Name "coderPackage")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the family field of hydra.build.format.LanguageProfile +languageProfileFamily :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String +languageProfileFamily x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.LanguageProfile"), + Model.projectionFieldName = (Model.Name "family")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.build.format.LanguageProfile +languageProfileLanguageProfile :: Typed.TypedName Format.LanguageProfile +languageProfileLanguageProfile = Typed.TypedName (Model.Name "hydra.build.format.LanguageProfile") + +-- | DSL accessor for the name field of hydra.build.format.LanguageProfile +languageProfileName :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String +languageProfileName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.LanguageProfile"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the coderPackage field of hydra.build.format.LanguageProfile +languageProfileWithCoderPackage :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile +languageProfileWithCoderPackage original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.LanguageProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.LanguageProfile"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "coderPackage"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "family"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.LanguageProfile"), + Model.projectionFieldName = (Model.Name "family")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the family field of hydra.build.format.LanguageProfile +languageProfileWithFamily :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile +languageProfileWithFamily original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.LanguageProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.LanguageProfile"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "coderPackage"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.LanguageProfile"), + Model.projectionFieldName = (Model.Name "coderPackage")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "family"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the name field of hydra.build.format.LanguageProfile +languageProfileWithName :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile +languageProfileWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.LanguageProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "coderPackage"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.LanguageProfile"), + Model.projectionFieldName = (Model.Name "coderPackage")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "family"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.LanguageProfile"), + Model.projectionFieldName = (Model.Name "family")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.build.format.ModuleValidationProfile +moduleValidationProfile :: Typed.TypedTerm (Maybe Format.DefinitionValidationProfile) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.ModuleValidationProfile +moduleValidationProfile definitions nameConvention conflictingVariantName = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "definitions"), + Model.fieldTerm = (Typed.unTypedTerm definitions)}, + Model.Field { + Model.fieldName = (Model.Name "nameConvention"), + Model.fieldTerm = (Typed.unTypedTerm nameConvention)}, + Model.Field { + Model.fieldName = (Model.Name "conflictingVariantName"), + Model.fieldTerm = (Typed.unTypedTerm conflictingVariantName)}]})) + +-- | DSL accessor for the conflictingVariantName field of hydra.build.format.ModuleValidationProfile +moduleValidationProfileConflictingVariantName :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) +moduleValidationProfileConflictingVariantName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"), + Model.projectionFieldName = (Model.Name "conflictingVariantName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the definitions field of hydra.build.format.ModuleValidationProfile +moduleValidationProfileDefinitions :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.DefinitionValidationProfile) +moduleValidationProfileDefinitions x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"), + Model.projectionFieldName = (Model.Name "definitions")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.build.format.ModuleValidationProfile +moduleValidationProfileModuleValidationProfile :: Typed.TypedName Format.ModuleValidationProfile +moduleValidationProfileModuleValidationProfile = Typed.TypedName (Model.Name "hydra.build.format.ModuleValidationProfile") + +-- | DSL accessor for the nameConvention field of hydra.build.format.ModuleValidationProfile +moduleValidationProfileNameConvention :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) +moduleValidationProfileNameConvention x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"), + Model.projectionFieldName = (Model.Name "nameConvention")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the conflictingVariantName field of hydra.build.format.ModuleValidationProfile +moduleValidationProfileWithConflictingVariantName :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.ModuleValidationProfile +moduleValidationProfileWithConflictingVariantName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "definitions"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"), + Model.projectionFieldName = (Model.Name "definitions")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "nameConvention"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"), + Model.projectionFieldName = (Model.Name "nameConvention")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "conflictingVariantName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the definitions field of hydra.build.format.ModuleValidationProfile +moduleValidationProfileWithDefinitions :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.DefinitionValidationProfile) -> Typed.TypedTerm Format.ModuleValidationProfile +moduleValidationProfileWithDefinitions original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "definitions"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "nameConvention"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"), + Model.projectionFieldName = (Model.Name "nameConvention")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "conflictingVariantName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"), + Model.projectionFieldName = (Model.Name "conflictingVariantName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the nameConvention field of hydra.build.format.ModuleValidationProfile +moduleValidationProfileWithNameConvention :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.ModuleValidationProfile +moduleValidationProfileWithNameConvention original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "definitions"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"), + Model.projectionFieldName = (Model.Name "definitions")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "nameConvention"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "conflictingVariantName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"), + Model.projectionFieldName = (Model.Name "conflictingVariantName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.build.format.OutputDigest +outputDigest :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm String -> Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe Format.Sha256Hash) -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) -> Typed.TypedTerm (M.Map String Format.DigestEntry) -> Typed.TypedTerm (M.Map String Format.DigestEntry) -> Typed.TypedTerm Format.OutputDigest +outputDigest digestFormatVersion moduleFormatVersion generator generation selfHash dependencyHashes inputs outputs = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "digestFormatVersion"), + Model.fieldTerm = (Typed.unTypedTerm digestFormatVersion)}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Typed.unTypedTerm moduleFormatVersion)}, + Model.Field { + Model.fieldName = (Model.Name "generator"), + Model.fieldTerm = (Typed.unTypedTerm generator)}, + Model.Field { + Model.fieldName = (Model.Name "generation"), + Model.fieldTerm = (Typed.unTypedTerm generation)}, + Model.Field { + Model.fieldName = (Model.Name "selfHash"), + Model.fieldTerm = (Typed.unTypedTerm selfHash)}, + Model.Field { + Model.fieldName = (Model.Name "dependencyHashes"), + Model.fieldTerm = (Typed.unTypedTerm dependencyHashes)}, + Model.Field { + Model.fieldName = (Model.Name "inputs"), + Model.fieldTerm = (Typed.unTypedTerm inputs)}, + Model.Field { + Model.fieldName = (Model.Name "outputs"), + Model.fieldTerm = (Typed.unTypedTerm outputs)}]})) + +-- | DSL accessor for the dependencyHashes field of hydra.build.format.OutputDigest +outputDigestDependencyHashes :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) +outputDigestDependencyHashes x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "dependencyHashes")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the digestFormatVersion field of hydra.build.format.OutputDigest +outputDigestDigestFormatVersion :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Int +outputDigestDigestFormatVersion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "digestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the generation field of hydra.build.format.OutputDigest +outputDigestGeneration :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Format.Generation +outputDigestGeneration x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "generation")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the generator field of hydra.build.format.OutputDigest +outputDigestGenerator :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm String +outputDigestGenerator x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "generator")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the inputs field of hydra.build.format.OutputDigest +outputDigestInputs :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map String Format.DigestEntry) +outputDigestInputs x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "inputs")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the moduleFormatVersion field of hydra.build.format.OutputDigest +outputDigestModuleFormatVersion :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Int +outputDigestModuleFormatVersion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.build.format.OutputDigest +outputDigestOutputDigest :: Typed.TypedName Format.OutputDigest +outputDigestOutputDigest = Typed.TypedName (Model.Name "hydra.build.format.OutputDigest") + +-- | DSL accessor for the outputs field of hydra.build.format.OutputDigest +outputDigestOutputs :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map String Format.DigestEntry) +outputDigestOutputs x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "outputs")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the selfHash field of hydra.build.format.OutputDigest +outputDigestSelfHash :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (Maybe Format.Sha256Hash) +outputDigestSelfHash x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "selfHash")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the dependencyHashes field of hydra.build.format.OutputDigest +outputDigestWithDependencyHashes :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) -> Typed.TypedTerm Format.OutputDigest +outputDigestWithDependencyHashes original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "digestFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "digestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "generator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "generator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "generation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "generation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "selfHash"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "selfHash")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependencyHashes"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "inputs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "inputs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "outputs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "outputs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the digestFormatVersion field of hydra.build.format.OutputDigest +outputDigestWithDigestFormatVersion :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.OutputDigest +outputDigestWithDigestFormatVersion original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "digestFormatVersion"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "generator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "generator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "generation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "generation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "selfHash"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "selfHash")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependencyHashes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "dependencyHashes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "inputs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "inputs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "outputs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "outputs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the generation field of hydra.build.format.OutputDigest +outputDigestWithGeneration :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.OutputDigest +outputDigestWithGeneration original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "digestFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "digestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "generator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "generator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "generation"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "selfHash"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "selfHash")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependencyHashes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "dependencyHashes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "inputs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "inputs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "outputs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "outputs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the generator field of hydra.build.format.OutputDigest +outputDigestWithGenerator :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm String -> Typed.TypedTerm Format.OutputDigest +outputDigestWithGenerator original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "digestFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "digestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "generator"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "generation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "generation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "selfHash"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "selfHash")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependencyHashes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "dependencyHashes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "inputs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "inputs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "outputs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "outputs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the inputs field of hydra.build.format.OutputDigest +outputDigestWithInputs :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map String Format.DigestEntry) -> Typed.TypedTerm Format.OutputDigest +outputDigestWithInputs original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "digestFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "digestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "generator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "generator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "generation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "generation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "selfHash"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "selfHash")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependencyHashes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "dependencyHashes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "inputs"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "outputs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "outputs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the moduleFormatVersion field of hydra.build.format.OutputDigest +outputDigestWithModuleFormatVersion :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.OutputDigest +outputDigestWithModuleFormatVersion original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "digestFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "digestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "generator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "generator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "generation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "generation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "selfHash"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "selfHash")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependencyHashes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "dependencyHashes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "inputs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "inputs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "outputs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "outputs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the outputs field of hydra.build.format.OutputDigest +outputDigestWithOutputs :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map String Format.DigestEntry) -> Typed.TypedTerm Format.OutputDigest +outputDigestWithOutputs original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "digestFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "digestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "generator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "generator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "generation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "generation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "selfHash"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "selfHash")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependencyHashes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "dependencyHashes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "inputs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "inputs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "outputs"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the selfHash field of hydra.build.format.OutputDigest +outputDigestWithSelfHash :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (Maybe Format.Sha256Hash) -> Typed.TypedTerm Format.OutputDigest +outputDigestWithSelfHash original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "digestFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "digestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "generator"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "generator")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "generation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "generation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "selfHash"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "dependencyHashes"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "dependencyHashes")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "inputs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "inputs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "outputs"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.projectionFieldName = (Model.Name "outputs")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.build.format.PackageDescriptor +packageDescriptor :: Typed.TypedTerm Int -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm (Maybe [Format.LanguageName]) -> Typed.TypedTerm [Packaging.PackageName] -> Typed.TypedTerm (Maybe Format.PackageValidationConfiguration) -> Typed.TypedTerm Format.PackageDescriptor +packageDescriptor packageFormatVersion name description sourceLanguage targetLanguages dependencies validation = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "packageFormatVersion"), + Model.fieldTerm = (Typed.unTypedTerm packageFormatVersion)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm name)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm description)}, + Model.Field { + Model.fieldName = (Model.Name "sourceLanguage"), + Model.fieldTerm = (Typed.unTypedTerm sourceLanguage)}, + Model.Field { + Model.fieldName = (Model.Name "targetLanguages"), + Model.fieldTerm = (Typed.unTypedTerm targetLanguages)}, + Model.Field { + Model.fieldName = (Model.Name "dependencies"), + Model.fieldTerm = (Typed.unTypedTerm dependencies)}, + Model.Field { + Model.fieldName = (Model.Name "validation"), + Model.fieldTerm = (Typed.unTypedTerm validation)}]})) + +-- | DSL accessor for the dependencies field of hydra.build.format.PackageDescriptor +packageDescriptorDependencies :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm [Packaging.PackageName] +packageDescriptorDependencies x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "dependencies")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the description field of hydra.build.format.PackageDescriptor +packageDescriptorDescription :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm String +packageDescriptorDescription x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the name field of hydra.build.format.PackageDescriptor +packageDescriptorName :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Packaging.PackageName +packageDescriptorName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.build.format.PackageDescriptor +packageDescriptorPackageDescriptor :: Typed.TypedName Format.PackageDescriptor +packageDescriptorPackageDescriptor = Typed.TypedName (Model.Name "hydra.build.format.PackageDescriptor") + +-- | DSL accessor for the packageFormatVersion field of hydra.build.format.PackageDescriptor +packageDescriptorPackageFormatVersion :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Int +packageDescriptorPackageFormatVersion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "packageFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the sourceLanguage field of hydra.build.format.PackageDescriptor +packageDescriptorSourceLanguage :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Format.LanguageName +packageDescriptorSourceLanguage x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "sourceLanguage")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the targetLanguages field of hydra.build.format.PackageDescriptor +packageDescriptorTargetLanguages :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm (Maybe [Format.LanguageName]) +packageDescriptorTargetLanguages x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "targetLanguages")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the validation field of hydra.build.format.PackageDescriptor +packageDescriptorValidation :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm (Maybe Format.PackageValidationConfiguration) +packageDescriptorValidation x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "validation")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the dependencies field of hydra.build.format.PackageDescriptor +packageDescriptorWithDependencies :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm [Packaging.PackageName] -> Typed.TypedTerm Format.PackageDescriptor +packageDescriptorWithDependencies original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "packageFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "packageFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "sourceLanguage"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "sourceLanguage")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "targetLanguages"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "targetLanguages")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependencies"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "validation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "validation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the description field of hydra.build.format.PackageDescriptor +packageDescriptorWithDescription :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.PackageDescriptor +packageDescriptorWithDescription original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "packageFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "packageFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "sourceLanguage"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "sourceLanguage")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "targetLanguages"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "targetLanguages")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependencies"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "dependencies")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "validation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "validation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the name field of hydra.build.format.PackageDescriptor +packageDescriptorWithName :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm Format.PackageDescriptor +packageDescriptorWithName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "packageFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "packageFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "sourceLanguage"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "sourceLanguage")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "targetLanguages"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "targetLanguages")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependencies"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "dependencies")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "validation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "validation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the packageFormatVersion field of hydra.build.format.PackageDescriptor +packageDescriptorWithPackageFormatVersion :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PackageDescriptor +packageDescriptorWithPackageFormatVersion original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "packageFormatVersion"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "sourceLanguage"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "sourceLanguage")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "targetLanguages"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "targetLanguages")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependencies"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "dependencies")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "validation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "validation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the sourceLanguage field of hydra.build.format.PackageDescriptor +packageDescriptorWithSourceLanguage :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm Format.PackageDescriptor +packageDescriptorWithSourceLanguage original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "packageFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "packageFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "sourceLanguage"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "targetLanguages"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "targetLanguages")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependencies"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "dependencies")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "validation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "validation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the targetLanguages field of hydra.build.format.PackageDescriptor +packageDescriptorWithTargetLanguages :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm (Maybe [Format.LanguageName]) -> Typed.TypedTerm Format.PackageDescriptor +packageDescriptorWithTargetLanguages original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "packageFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "packageFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "sourceLanguage"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "sourceLanguage")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "targetLanguages"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "dependencies"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "dependencies")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "validation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "validation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the validation field of hydra.build.format.PackageDescriptor +packageDescriptorWithValidation :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm (Maybe Format.PackageValidationConfiguration) -> Typed.TypedTerm Format.PackageDescriptor +packageDescriptorWithValidation original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "packageFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "packageFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "name")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "description")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "sourceLanguage"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "sourceLanguage")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "targetLanguages"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "targetLanguages")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "dependencies"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.projectionFieldName = (Model.Name "dependencies")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "validation"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.build.format.PackageManifest +packageManifest :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest +packageManifest manifestFormatVersion moduleFormatVersion package mainModules testModules mainDslModules mainEncodingModules = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "manifestFormatVersion"), + Model.fieldTerm = (Typed.unTypedTerm manifestFormatVersion)}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Typed.unTypedTerm moduleFormatVersion)}, + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Typed.unTypedTerm package)}, + Model.Field { + Model.fieldName = (Model.Name "mainModules"), + Model.fieldTerm = (Typed.unTypedTerm mainModules)}, + Model.Field { + Model.fieldName = (Model.Name "testModules"), + Model.fieldTerm = (Typed.unTypedTerm testModules)}, + Model.Field { + Model.fieldName = (Model.Name "mainDslModules"), + Model.fieldTerm = (Typed.unTypedTerm mainDslModules)}, + Model.Field { + Model.fieldName = (Model.Name "mainEncodingModules"), + Model.fieldTerm = (Typed.unTypedTerm mainEncodingModules)}]})) + +-- | DSL accessor for the mainDslModules field of hydra.build.format.PackageManifest +packageManifestMainDslModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] +packageManifestMainDslModules x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainDslModules")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the mainEncodingModules field of hydra.build.format.PackageManifest +packageManifestMainEncodingModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] +packageManifestMainEncodingModules x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainEncodingModules")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the mainModules field of hydra.build.format.PackageManifest +packageManifestMainModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] +packageManifestMainModules x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainModules")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the manifestFormatVersion field of hydra.build.format.PackageManifest +packageManifestManifestFormatVersion :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Int +packageManifestManifestFormatVersion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "manifestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the moduleFormatVersion field of hydra.build.format.PackageManifest +packageManifestModuleFormatVersion :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Int +packageManifestModuleFormatVersion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the package field of hydra.build.format.PackageManifest +packageManifestPackage :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Packaging.PackageName +packageManifestPackage x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.build.format.PackageManifest +packageManifestPackageManifest :: Typed.TypedName Format.PackageManifest +packageManifestPackageManifest = Typed.TypedName (Model.Name "hydra.build.format.PackageManifest") + +-- | DSL accessor for the testModules field of hydra.build.format.PackageManifest +packageManifestTestModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] +packageManifestTestModules x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "testModules")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the mainDslModules field of hydra.build.format.PackageManifest +packageManifestWithMainDslModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest +packageManifestWithMainDslModules original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "manifestFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "manifestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mainModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "testModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "testModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mainDslModules"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "mainEncodingModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainEncodingModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the mainEncodingModules field of hydra.build.format.PackageManifest +packageManifestWithMainEncodingModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest +packageManifestWithMainEncodingModules original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "manifestFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "manifestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mainModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "testModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "testModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mainDslModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainDslModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mainEncodingModules"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the mainModules field of hydra.build.format.PackageManifest +packageManifestWithMainModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest +packageManifestWithMainModules original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "manifestFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "manifestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mainModules"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "testModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "testModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mainDslModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainDslModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mainEncodingModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainEncodingModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the manifestFormatVersion field of hydra.build.format.PackageManifest +packageManifestWithManifestFormatVersion :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PackageManifest +packageManifestWithManifestFormatVersion original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "manifestFormatVersion"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mainModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "testModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "testModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mainDslModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainDslModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mainEncodingModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainEncodingModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the moduleFormatVersion field of hydra.build.format.PackageManifest +packageManifestWithModuleFormatVersion :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PackageManifest +packageManifestWithModuleFormatVersion original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "manifestFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "manifestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mainModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "testModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "testModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mainDslModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainDslModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mainEncodingModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainEncodingModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the package field of hydra.build.format.PackageManifest +packageManifestWithPackage :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm Format.PackageManifest +packageManifestWithPackage original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "manifestFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "manifestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "mainModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "testModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "testModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mainDslModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainDslModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mainEncodingModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainEncodingModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the testModules field of hydra.build.format.PackageManifest +packageManifestWithTestModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest +packageManifestWithTestModules original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "manifestFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "manifestFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "moduleFormatVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mainModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "testModules"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "mainDslModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainDslModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "mainEncodingModules"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.projectionFieldName = (Model.Name "mainEncodingModules")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.build.format.PackageValidationConfiguration +packageValidationConfiguration :: Typed.TypedTerm (Maybe Format.PackageValidationProfile) -> Typed.TypedTerm (Maybe Format.ModuleValidationProfile) -> Typed.TypedTerm (Maybe Format.TypeValidationProfile) -> Typed.TypedTerm (Maybe Format.TermValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration +packageValidationConfiguration package module_ type_ term = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Typed.unTypedTerm package)}, + Model.Field { + Model.fieldName = (Model.Name "module"), + Model.fieldTerm = (Typed.unTypedTerm module_)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm type_)}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Typed.unTypedTerm term)}]})) + +-- | DSL accessor for the module field of hydra.build.format.PackageValidationConfiguration +packageValidationConfigurationModule :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.ModuleValidationProfile) +packageValidationConfigurationModule x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.projectionFieldName = (Model.Name "module")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the package field of hydra.build.format.PackageValidationConfiguration +packageValidationConfigurationPackage :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.PackageValidationProfile) +packageValidationConfigurationPackage x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.build.format.PackageValidationConfiguration +packageValidationConfigurationPackageValidationConfiguration :: Typed.TypedName Format.PackageValidationConfiguration +packageValidationConfigurationPackageValidationConfiguration = + Typed.TypedName (Model.Name "hydra.build.format.PackageValidationConfiguration") + +-- | DSL accessor for the term field of hydra.build.format.PackageValidationConfiguration +packageValidationConfigurationTerm :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.TermValidationProfile) +packageValidationConfigurationTerm x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.projectionFieldName = (Model.Name "term")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the type field of hydra.build.format.PackageValidationConfiguration +packageValidationConfigurationType :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.TypeValidationProfile) +packageValidationConfigurationType x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the module field of hydra.build.format.PackageValidationConfiguration +packageValidationConfigurationWithModule :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.ModuleValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration +packageValidationConfigurationWithModule original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "module"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.projectionFieldName = (Model.Name "term")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the package field of hydra.build.format.PackageValidationConfiguration +packageValidationConfigurationWithPackage :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.PackageValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration +packageValidationConfigurationWithPackage original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "module"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.projectionFieldName = (Model.Name "module")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.projectionFieldName = (Model.Name "term")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the term field of hydra.build.format.PackageValidationConfiguration +packageValidationConfigurationWithTerm :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.TermValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration +packageValidationConfigurationWithTerm original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "module"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.projectionFieldName = (Model.Name "module")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.projectionFieldName = (Model.Name "type")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the type field of hydra.build.format.PackageValidationConfiguration +packageValidationConfigurationWithType :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.TypeValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration +packageValidationConfigurationWithType original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.projectionFieldName = (Model.Name "package")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "module"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.projectionFieldName = (Model.Name "module")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.projectionFieldName = (Model.Name "term")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL constructor for hydra.build.format.PackageValidationProfile +packageValidationProfile :: Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.PackageValidationProfile +packageValidationProfile conflictingModuleName duplicateModuleName nameConvention = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "conflictingModuleName"), + Model.fieldTerm = (Typed.unTypedTerm conflictingModuleName)}, + Model.Field { + Model.fieldName = (Model.Name "duplicateModuleName"), + Model.fieldTerm = (Typed.unTypedTerm duplicateModuleName)}, + Model.Field { + Model.fieldName = (Model.Name "nameConvention"), + Model.fieldTerm = (Typed.unTypedTerm nameConvention)}]})) + +-- | DSL accessor for the conflictingModuleName field of hydra.build.format.PackageValidationProfile +packageValidationProfileConflictingModuleName :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) +packageValidationProfileConflictingModuleName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"), + Model.projectionFieldName = (Model.Name "conflictingModuleName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the duplicateModuleName field of hydra.build.format.PackageValidationProfile +packageValidationProfileDuplicateModuleName :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) +packageValidationProfileDuplicateModuleName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"), + Model.projectionFieldName = (Model.Name "duplicateModuleName")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the nameConvention field of hydra.build.format.PackageValidationProfile +packageValidationProfileNameConvention :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) +packageValidationProfileNameConvention x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"), + Model.projectionFieldName = (Model.Name "nameConvention")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.build.format.PackageValidationProfile +packageValidationProfilePackageValidationProfile :: Typed.TypedName Format.PackageValidationProfile +packageValidationProfilePackageValidationProfile = + Typed.TypedName (Model.Name "hydra.build.format.PackageValidationProfile") + +-- | DSL updater for the conflictingModuleName field of hydra.build.format.PackageValidationProfile +packageValidationProfileWithConflictingModuleName :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.PackageValidationProfile +packageValidationProfileWithConflictingModuleName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "conflictingModuleName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "duplicateModuleName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"), + Model.projectionFieldName = (Model.Name "duplicateModuleName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "nameConvention"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"), + Model.projectionFieldName = (Model.Name "nameConvention")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the duplicateModuleName field of hydra.build.format.PackageValidationProfile +packageValidationProfileWithDuplicateModuleName :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.PackageValidationProfile +packageValidationProfileWithDuplicateModuleName original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "conflictingModuleName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"), + Model.projectionFieldName = (Model.Name "conflictingModuleName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "duplicateModuleName"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "nameConvention"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"), + Model.projectionFieldName = (Model.Name "nameConvention")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the nameConvention field of hydra.build.format.PackageValidationProfile +packageValidationProfileWithNameConvention :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.PackageValidationProfile +packageValidationProfileWithNameConvention original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "conflictingModuleName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"), + Model.projectionFieldName = (Model.Name "conflictingModuleName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "duplicateModuleName"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"), + Model.projectionFieldName = (Model.Name "duplicateModuleName")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "nameConvention"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.build.format.RepositoryDescriptor +repositoryDescriptor :: Typed.TypedTerm Packaging.Version -> Typed.TypedTerm Packaging.Version -> Typed.TypedTerm (M.Map Format.LanguageName Format.HostOverride) -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm [Packaging.PackageName] -> Typed.TypedTerm Format.RepositoryDescriptor +repositoryDescriptor currentVersion hostVersion hostOverrides group author url license packages = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "currentVersion"), + Model.fieldTerm = (Typed.unTypedTerm currentVersion)}, + Model.Field { + Model.fieldName = (Model.Name "hostVersion"), + Model.fieldTerm = (Typed.unTypedTerm hostVersion)}, + Model.Field { + Model.fieldName = (Model.Name "hostOverrides"), + Model.fieldTerm = (Typed.unTypedTerm hostOverrides)}, + Model.Field { + Model.fieldName = (Model.Name "group"), + Model.fieldTerm = (Typed.unTypedTerm group)}, + Model.Field { + Model.fieldName = (Model.Name "author"), + Model.fieldTerm = (Typed.unTypedTerm author)}, + Model.Field { + Model.fieldName = (Model.Name "url"), + Model.fieldTerm = (Typed.unTypedTerm url)}, + Model.Field { + Model.fieldName = (Model.Name "license"), + Model.fieldTerm = (Typed.unTypedTerm license)}, + Model.Field { + Model.fieldName = (Model.Name "packages"), + Model.fieldTerm = (Typed.unTypedTerm packages)}]})) + +-- | DSL accessor for the author field of hydra.build.format.RepositoryDescriptor +repositoryDescriptorAuthor :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String +repositoryDescriptorAuthor x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "author")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the currentVersion field of hydra.build.format.RepositoryDescriptor +repositoryDescriptorCurrentVersion :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm Packaging.Version +repositoryDescriptorCurrentVersion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "currentVersion")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the group field of hydra.build.format.RepositoryDescriptor +repositoryDescriptorGroup :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String +repositoryDescriptorGroup x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "group")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the hostOverrides field of hydra.build.format.RepositoryDescriptor +repositoryDescriptorHostOverrides :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm (M.Map Format.LanguageName Format.HostOverride) +repositoryDescriptorHostOverrides x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "hostOverrides")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the hostVersion field of hydra.build.format.RepositoryDescriptor +repositoryDescriptorHostVersion :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm Packaging.Version +repositoryDescriptorHostVersion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "hostVersion")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the license field of hydra.build.format.RepositoryDescriptor +repositoryDescriptorLicense :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String +repositoryDescriptorLicense x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "license")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the packages field of hydra.build.format.RepositoryDescriptor +repositoryDescriptorPackages :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm [Packaging.PackageName] +repositoryDescriptorPackages x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "packages")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.build.format.RepositoryDescriptor +repositoryDescriptorRepositoryDescriptor :: Typed.TypedName Format.RepositoryDescriptor +repositoryDescriptorRepositoryDescriptor = Typed.TypedName (Model.Name "hydra.build.format.RepositoryDescriptor") + +-- | DSL accessor for the url field of hydra.build.format.RepositoryDescriptor +repositoryDescriptorUrl :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String +repositoryDescriptorUrl x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "url")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the author field of hydra.build.format.RepositoryDescriptor +repositoryDescriptorWithAuthor :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.RepositoryDescriptor +repositoryDescriptorWithAuthor original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "currentVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "currentVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hostVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "hostVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hostOverrides"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "hostOverrides")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "group"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "group")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "author"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "url"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "url")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "license"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "license")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "packages"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "packages")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the currentVersion field of hydra.build.format.RepositoryDescriptor +repositoryDescriptorWithCurrentVersion :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm Packaging.Version -> Typed.TypedTerm Format.RepositoryDescriptor +repositoryDescriptorWithCurrentVersion original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "currentVersion"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "hostVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "hostVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hostOverrides"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "hostOverrides")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "group"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "group")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "author"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "author")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "url"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "url")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "license"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "license")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "packages"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "packages")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the group field of hydra.build.format.RepositoryDescriptor +repositoryDescriptorWithGroup :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.RepositoryDescriptor +repositoryDescriptorWithGroup original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "currentVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "currentVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hostVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "hostVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hostOverrides"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "hostOverrides")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "group"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "author"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "author")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "url"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "url")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "license"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "license")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "packages"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "packages")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the hostOverrides field of hydra.build.format.RepositoryDescriptor +repositoryDescriptorWithHostOverrides :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm (M.Map Format.LanguageName Format.HostOverride) -> Typed.TypedTerm Format.RepositoryDescriptor +repositoryDescriptorWithHostOverrides original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "currentVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "currentVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hostVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "hostVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hostOverrides"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "group"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "group")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "author"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "author")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "url"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "url")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "license"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "license")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "packages"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "packages")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the hostVersion field of hydra.build.format.RepositoryDescriptor +repositoryDescriptorWithHostVersion :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm Packaging.Version -> Typed.TypedTerm Format.RepositoryDescriptor +repositoryDescriptorWithHostVersion original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "currentVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "currentVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hostVersion"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "hostOverrides"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "hostOverrides")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "group"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "group")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "author"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "author")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "url"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "url")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "license"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "license")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "packages"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "packages")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the license field of hydra.build.format.RepositoryDescriptor +repositoryDescriptorWithLicense :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.RepositoryDescriptor +repositoryDescriptorWithLicense original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "currentVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "currentVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hostVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "hostVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hostOverrides"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "hostOverrides")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "group"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "group")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "author"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "author")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "url"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "url")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "license"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "packages"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "packages")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the packages field of hydra.build.format.RepositoryDescriptor +repositoryDescriptorWithPackages :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm [Packaging.PackageName] -> Typed.TypedTerm Format.RepositoryDescriptor +repositoryDescriptorWithPackages original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "currentVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "currentVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hostVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "hostVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hostOverrides"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "hostOverrides")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "group"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "group")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "author"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "author")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "url"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "url")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "license"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "license")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "packages"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the url field of hydra.build.format.RepositoryDescriptor +repositoryDescriptorWithUrl :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.RepositoryDescriptor +repositoryDescriptorWithUrl original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "currentVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "currentVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hostVersion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "hostVersion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "hostOverrides"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "hostOverrides")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "group"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "group")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "author"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "author")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "url"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "license"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "license")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "packages"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.projectionFieldName = (Model.Name "packages")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL injection for the error variant of hydra.build.format.Severity +severityError :: Typed.TypedTerm Format.Severity +severityError = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.Severity"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "error"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL name token for hydra.build.format.Severity +severitySeverity :: Typed.TypedName Format.Severity +severitySeverity = Typed.TypedName (Model.Name "hydra.build.format.Severity") + +-- | DSL injection for the warning variant of hydra.build.format.Severity +severityWarning :: Typed.TypedTerm Format.Severity +severityWarning = + Typed.TypedTerm (Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.Severity"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "warning"), + Model.fieldTerm = Model.TermUnit}})) + +-- | DSL constructor for the hydra.build.format.Sha256Hash wrapper +sha256Hash :: Typed.TypedTerm String -> Typed.TypedTerm Format.Sha256Hash +sha256Hash x = + Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.build.format.Sha256Hash"), + Model.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.build.format.Sha256Hash +sha256HashSha256Hash :: Typed.TypedName Format.Sha256Hash +sha256HashSha256Hash = Typed.TypedName (Model.Name "hydra.build.format.Sha256Hash") + +-- | DSL constructor for hydra.build.format.TermValidationProfile +termValidationProfile :: Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TermValidationProfile +termValidationProfile duplicateBinding emptyTermAnnotation undefinedVariable = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.TermValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "duplicateBinding"), + Model.fieldTerm = (Typed.unTypedTerm duplicateBinding)}, + Model.Field { + Model.fieldName = (Model.Name "emptyTermAnnotation"), + Model.fieldTerm = (Typed.unTypedTerm emptyTermAnnotation)}, + Model.Field { + Model.fieldName = (Model.Name "undefinedVariable"), + Model.fieldTerm = (Typed.unTypedTerm undefinedVariable)}]})) + +-- | DSL accessor for the duplicateBinding field of hydra.build.format.TermValidationProfile +termValidationProfileDuplicateBinding :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) +termValidationProfileDuplicateBinding x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.TermValidationProfile"), + Model.projectionFieldName = (Model.Name "duplicateBinding")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the emptyTermAnnotation field of hydra.build.format.TermValidationProfile +termValidationProfileEmptyTermAnnotation :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) +termValidationProfileEmptyTermAnnotation x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.TermValidationProfile"), + Model.projectionFieldName = (Model.Name "emptyTermAnnotation")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.build.format.TermValidationProfile +termValidationProfileTermValidationProfile :: Typed.TypedName Format.TermValidationProfile +termValidationProfileTermValidationProfile = Typed.TypedName (Model.Name "hydra.build.format.TermValidationProfile") + +-- | DSL accessor for the undefinedVariable field of hydra.build.format.TermValidationProfile +termValidationProfileUndefinedVariable :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) +termValidationProfileUndefinedVariable x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.TermValidationProfile"), + Model.projectionFieldName = (Model.Name "undefinedVariable")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL updater for the duplicateBinding field of hydra.build.format.TermValidationProfile +termValidationProfileWithDuplicateBinding :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TermValidationProfile +termValidationProfileWithDuplicateBinding original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.TermValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "duplicateBinding"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "emptyTermAnnotation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.TermValidationProfile"), + Model.projectionFieldName = (Model.Name "emptyTermAnnotation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "undefinedVariable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.TermValidationProfile"), + Model.projectionFieldName = (Model.Name "undefinedVariable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the emptyTermAnnotation field of hydra.build.format.TermValidationProfile +termValidationProfileWithEmptyTermAnnotation :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TermValidationProfile +termValidationProfileWithEmptyTermAnnotation original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.TermValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "duplicateBinding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.TermValidationProfile"), + Model.projectionFieldName = (Model.Name "duplicateBinding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "emptyTermAnnotation"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "undefinedVariable"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.TermValidationProfile"), + Model.projectionFieldName = (Model.Name "undefinedVariable")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the undefinedVariable field of hydra.build.format.TermValidationProfile +termValidationProfileWithUndefinedVariable :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TermValidationProfile +termValidationProfileWithUndefinedVariable original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.TermValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "duplicateBinding"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.TermValidationProfile"), + Model.projectionFieldName = (Model.Name "duplicateBinding")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "emptyTermAnnotation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.TermValidationProfile"), + Model.projectionFieldName = (Model.Name "emptyTermAnnotation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "undefinedVariable"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.build.format.TypeValidationProfile +typeValidationProfile :: Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TypeValidationProfile +typeValidationProfile emptyAnnotation duplicateField singleVariantUnion = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "emptyAnnotation"), + Model.fieldTerm = (Typed.unTypedTerm emptyAnnotation)}, + Model.Field { + Model.fieldName = (Model.Name "duplicateField"), + Model.fieldTerm = (Typed.unTypedTerm duplicateField)}, + Model.Field { + Model.fieldName = (Model.Name "singleVariantUnion"), + Model.fieldTerm = (Typed.unTypedTerm singleVariantUnion)}]})) + +-- | DSL accessor for the duplicateField field of hydra.build.format.TypeValidationProfile +typeValidationProfileDuplicateField :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) +typeValidationProfileDuplicateField x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"), + Model.projectionFieldName = (Model.Name "duplicateField")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the emptyAnnotation field of hydra.build.format.TypeValidationProfile +typeValidationProfileEmptyAnnotation :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) +typeValidationProfileEmptyAnnotation x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"), + Model.projectionFieldName = (Model.Name "emptyAnnotation")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the singleVariantUnion field of hydra.build.format.TypeValidationProfile +typeValidationProfileSingleVariantUnion :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) +typeValidationProfileSingleVariantUnion x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"), + Model.projectionFieldName = (Model.Name "singleVariantUnion")})), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.build.format.TypeValidationProfile +typeValidationProfileTypeValidationProfile :: Typed.TypedName Format.TypeValidationProfile +typeValidationProfileTypeValidationProfile = Typed.TypedName (Model.Name "hydra.build.format.TypeValidationProfile") + +-- | DSL updater for the duplicateField field of hydra.build.format.TypeValidationProfile +typeValidationProfileWithDuplicateField :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TypeValidationProfile +typeValidationProfileWithDuplicateField original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "emptyAnnotation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"), + Model.projectionFieldName = (Model.Name "emptyAnnotation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "duplicateField"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "singleVariantUnion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"), + Model.projectionFieldName = (Model.Name "singleVariantUnion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the emptyAnnotation field of hydra.build.format.TypeValidationProfile +typeValidationProfileWithEmptyAnnotation :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TypeValidationProfile +typeValidationProfileWithEmptyAnnotation original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "emptyAnnotation"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}, + Model.Field { + Model.fieldName = (Model.Name "duplicateField"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"), + Model.projectionFieldName = (Model.Name "duplicateField")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "singleVariantUnion"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"), + Model.projectionFieldName = (Model.Name "singleVariantUnion")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the singleVariantUnion field of hydra.build.format.TypeValidationProfile +typeValidationProfileWithSingleVariantUnion :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TypeValidationProfile +typeValidationProfileWithSingleVariantUnion original newVal = + Typed.TypedTerm (Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "emptyAnnotation"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"), + Model.projectionFieldName = (Model.Name "emptyAnnotation")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "duplicateField"), + Model.fieldTerm = (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermProject (Model.Projection { + Model.projectionTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"), + Model.projectionFieldName = (Model.Name "duplicateField")})), + Model.applicationArgument = (Typed.unTypedTerm original)}))}, + Model.Field { + Model.fieldName = (Model.Name "singleVariantUnion"), + Model.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL accessor for the body of hydra.build.format.LanguageName +unLanguageName :: Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm String +unLanguageName x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.build.format.LanguageName")), + Model.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the body of hydra.build.format.Sha256Hash +unSha256Hash :: Typed.TypedTerm Format.Sha256Hash -> Typed.TypedTerm String +unSha256Hash x = + Typed.TypedTerm (Model.TermApplication (Model.Application { + Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.build.format.Sha256Hash")), + Model.applicationArgument = (Typed.unTypedTerm x)})) diff --git a/src/main/haskell/Hydra/Build/Encode/Assembly.hs b/src/main/haskell/Hydra/Build/Encode/Assembly.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Build/Encode/Assembly.hs @@ -0,0 +1,82 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Term encoders for hydra.build.assembly + +module Hydra.Build.Encode.Assembly where + +import qualified Hydra.Build.Assembly as Assembly +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Encoder for hydra.build.assembly.AssemblyEntry +assemblyEntry :: Assembly.AssemblyEntry -> Model.Term +assemblyEntry x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "sourceTree"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Assembly.assemblyEntrySourceTree x))}, + Model.Field { + Model.fieldName = (Model.Name "destTree"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Assembly.assemblyEntryDestTree x))}, + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (assemblyEntryKind (Assembly.assemblyEntryKind x))}, + Model.Field { + Model.fieldName = (Model.Name "exclude"), + Model.fieldTerm = ((\xs -> Model.TermList (Lists.map (\x2 -> Model.TermLiteral (Model.LiteralString x2)) xs)) (Assembly.assemblyEntryExclude x))}]}) + +-- | Encoder for hydra.build.assembly.AssemblyEntryKind +assemblyEntryKind :: Assembly.AssemblyEntryKind -> Model.Term +assemblyEntryKind x = + case x of + Assembly.AssemblyEntryKindMerge -> Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntryKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "merge"), + Model.fieldTerm = Model.TermUnit}}) + Assembly.AssemblyEntryKindWipeThenCopy -> Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntryKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "wipeThenCopy"), + Model.fieldTerm = Model.TermUnit}}) + Assembly.AssemblyEntryKindSymlinkTree -> Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntryKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "symlinkTree"), + Model.fieldTerm = Model.TermUnit}}) + Assembly.AssemblyEntryKindSymlinkDir -> Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntryKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "symlinkDir"), + Model.fieldTerm = Model.TermUnit}}) + +-- | Encoder for hydra.build.assembly.AssemblyPlan +assemblyPlan :: Assembly.AssemblyPlan -> Model.Term +assemblyPlan x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyPlan"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "entries"), + Model.fieldTerm = ((\xs -> Model.TermList (Lists.map assemblyEntry xs)) (Assembly.assemblyPlanEntries x))}, + Model.Field { + Model.fieldName = (Model.Name "keepPaths"), + Model.fieldTerm = ((\xs -> Model.TermList (Lists.map keepPathEntry xs)) (Assembly.assemblyPlanKeepPaths x))}]}) + +-- | Encoder for hydra.build.assembly.KeepPathEntry +keepPathEntry :: Assembly.KeepPathEntry -> Model.Term +keepPathEntry x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.assembly.KeepPathEntry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "sourceSetDir"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Assembly.keepPathEntrySourceSetDir x))}, + Model.Field { + Model.fieldName = (Model.Name "relPath"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Assembly.keepPathEntryRelPath x))}]}) diff --git a/src/main/haskell/Hydra/Build/Encode/Benchresult.hs b/src/main/haskell/Hydra/Build/Encode/Benchresult.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Build/Encode/Benchresult.hs @@ -0,0 +1,81 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Term encoders for hydra.build.benchresult + +module Hydra.Build.Encode.Benchresult where + +import qualified Hydra.Build.Benchresult as Benchresult +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Encoder for hydra.build.benchresult.BenchMetadata +benchMetadata :: Benchresult.BenchMetadata -> Model.Term +benchMetadata x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "timestamp"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Benchresult.benchMetadataTimestamp x))}, + Model.Field { + Model.fieldName = (Model.Name "language"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Benchresult.benchMetadataLanguage x))}, + Model.Field { + Model.fieldName = (Model.Name "branch"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Benchresult.benchMetadataBranch x))}, + Model.Field { + Model.fieldName = (Model.Name "commit"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Benchresult.benchMetadataCommit x))}, + Model.Field { + Model.fieldName = (Model.Name "commitMessage"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Benchresult.benchMetadataCommitMessage x))}]}) + +-- | Encoder for hydra.build.benchresult.GenBenchResult +genBenchResult :: Benchresult.GenBenchResult -> Model.Term +genBenchResult x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "target"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Benchresult.genBenchResultTarget x))}, + Model.Field { + Model.fieldName = (Model.Name "runs"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) (Benchresult.genBenchResultRuns x))}, + Model.Field { + Model.fieldName = (Model.Name "hosts"), + Model.fieldTerm = ((\m -> Model.TermMap (Maps.bimap (\x2 -> Model.TermLiteral (Model.LiteralString x2)) hostResult m)) (Benchresult.genBenchResultHosts x))}, + Model.Field { + Model.fieldName = (Model.Name "metadata"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map benchMetadata opt)) (Benchresult.genBenchResultMetadata x))}]}) + +-- | Encoder for hydra.build.benchresult.HostResult +hostResult :: Benchresult.HostResult -> Model.Term +hostResult x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.HostResult"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "setupMs"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) (Benchresult.hostResultSetupMs x))}, + Model.Field { + Model.fieldName = (Model.Name "packages"), + Model.fieldTerm = ((\m -> Model.TermMap (Maps.bimap (\x2 -> Model.TermLiteral (Model.LiteralString x2)) runStats m)) (Benchresult.hostResultPackages x))}]}) + +-- | Encoder for hydra.build.benchresult.RunStats +runStats :: Benchresult.RunStats -> Model.Term +runStats x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.benchresult.RunStats"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "runsMs"), + Model.fieldTerm = ((\xs -> Model.TermList (Lists.map (\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) xs)) (Benchresult.runStatsRunsMs x))}, + Model.Field { + Model.fieldName = (Model.Name "medianMs"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) (Benchresult.runStatsMedianMs x))}]}) diff --git a/src/main/haskell/Hydra/Build/Encode/Comparereport.hs b/src/main/haskell/Hydra/Build/Encode/Comparereport.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Build/Encode/Comparereport.hs @@ -0,0 +1,70 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Term encoders for hydra.build.comparereport + +module Hydra.Build.Encode.Comparereport where + +import qualified Hydra.Build.Comparereport as Comparereport +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Encoder for hydra.build.comparereport.CompareReport +compareReport :: Comparereport.CompareReport -> Model.Term +compareReport x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.comparereport.CompareReport"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "rows"), + Model.fieldTerm = ((\xs -> Model.TermList (Lists.map moduleCompare xs)) (Comparereport.compareReportRows x))}, + Model.Field { + Model.fieldName = (Model.Name "byteEqCount"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) (Comparereport.compareReportByteEqCount x))}, + Model.Field { + Model.fieldName = (Model.Name "total"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) (Comparereport.compareReportTotal x))}]}) + +-- | Encoder for hydra.build.comparereport.CompareStatus +compareStatus :: Comparereport.CompareStatus -> Model.Term +compareStatus x = + case x of + Comparereport.CompareStatusByteEq -> Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.comparereport.CompareStatus"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "byteEq"), + Model.fieldTerm = Model.TermUnit}}) + Comparereport.CompareStatusDiffer -> Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.comparereport.CompareStatus"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "differ"), + Model.fieldTerm = Model.TermUnit}}) + Comparereport.CompareStatusMissing -> Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.comparereport.CompareStatus"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "missing"), + Model.fieldTerm = Model.TermUnit}}) + +-- | Encoder for hydra.build.comparereport.ModuleCompare +moduleCompare :: Comparereport.ModuleCompare -> Model.Term +moduleCompare x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "module"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Comparereport.moduleCompareModule x))}, + Model.Field { + Model.fieldName = (Model.Name "status"), + Model.fieldTerm = (compareStatus (Comparereport.moduleCompareStatus x))}, + Model.Field { + Model.fieldName = (Model.Name "ourSize"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) (Comparereport.moduleCompareOurSize x))}, + Model.Field { + Model.fieldName = (Model.Name "canonSize"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) (Comparereport.moduleCompareCanonSize x))}, + Model.Field { + Model.fieldName = (Model.Name "diffLines"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) (Comparereport.moduleCompareDiffLines x))}]}) diff --git a/src/main/haskell/Hydra/Build/Encode/Format.hs b/src/main/haskell/Hydra/Build/Encode/Format.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Build/Encode/Format.hs @@ -0,0 +1,429 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Term encoders for hydra.build.format + +module Hydra.Build.Encode.Format where + +import qualified Hydra.Build.Format as Format +import qualified Hydra.Core.Encode.Packaging as Packaging +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) +import qualified Data.Scientific as Sci +import Data.Void + +-- | Encoder for hydra.build.format.DefinitionNameConventionProfile +definitionNameConventionProfile :: Format.DefinitionNameConventionProfile -> Model.Term +definitionNameConventionProfile x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionNameConventionProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (severity (Format.definitionNameConventionProfileSeverity x))}, + Model.Field { + Model.fieldName = (Model.Name "allowUnderscores"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralBoolean x2)) (Format.definitionNameConventionProfileAllowUnderscores x))}]}) + +-- | Encoder for hydra.build.format.DefinitionValidationProfile +definitionValidationProfile :: Format.DefinitionValidationProfile -> Model.Term +definitionValidationProfile x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "hasDescription"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map documentationProfile opt)) (Format.definitionValidationProfileHasDescription x))}, + Model.Field { + Model.fieldName = (Model.Name "ordering"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map severity opt)) (Format.definitionValidationProfileOrdering x))}, + Model.Field { + Model.fieldName = (Model.Name "nameConvention"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map definitionNameConventionProfile opt)) (Format.definitionValidationProfileNameConvention x))}, + Model.Field { + Model.fieldName = (Model.Name "notInModuleName"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map severity opt)) (Format.definitionValidationProfileNotInModuleName x))}, + Model.Field { + Model.fieldName = (Model.Name "duplicateName"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map severity opt)) (Format.definitionValidationProfileDuplicateName x))}]}) + +-- | Encoder for hydra.build.format.DigestEntry +digestEntry :: Format.DigestEntry -> Model.Term +digestEntry x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.DigestEntry"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "kind"), + Model.fieldTerm = (digestKind (Format.digestEntryKind x))}, + Model.Field { + Model.fieldName = (Model.Name "hash"), + Model.fieldTerm = (sha256Hash (Format.digestEntryHash x))}]}) + +-- | Encoder for hydra.build.format.DigestKind +digestKind :: Format.DigestKind -> Model.Term +digestKind x = + case x of + Format.DigestKindDslSource -> Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.DigestKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "dslSource"), + Model.fieldTerm = Model.TermUnit}}) + Format.DigestKindJsonFile -> Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.DigestKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "jsonFile"), + Model.fieldTerm = Model.TermUnit}}) + Format.DigestKindTargetFile -> Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.DigestKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "targetFile"), + Model.fieldTerm = Model.TermUnit}}) + Format.DigestKindRuntimeFile -> Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.DigestKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "runtimeFile"), + Model.fieldTerm = Model.TermUnit}}) + Format.DigestKindOther -> Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.DigestKind"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "other"), + Model.fieldTerm = Model.TermUnit}}) + +-- | Encoder for hydra.build.format.DocumentationProfile +documentationProfile :: Format.DocumentationProfile -> Model.Term +documentationProfile x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.DocumentationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "severity"), + Model.fieldTerm = (severity (Format.documentationProfileSeverity x))}, + Model.Field { + Model.fieldName = (Model.Name "exemptDeprecated"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralBoolean x2)) (Format.documentationProfileExemptDeprecated x))}]}) + +-- | Encoder for hydra.build.format.Generation +generation :: Format.Generation -> Model.Term +generation x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.Generation"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "generatorId"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Format.generationGeneratorId x))}, + Model.Field { + Model.fieldName = (Model.Name "mode"), + Model.fieldTerm = (generationMode (Format.generationMode x))}, + Model.Field { + Model.fieldName = (Model.Name "host"), + Model.fieldTerm = (languageName (Format.generationHost x))}, + Model.Field { + Model.fieldName = (Model.Name "hydraVersion"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map Packaging.version opt)) (Format.generationHydraVersion x))}, + Model.Field { + Model.fieldName = (Model.Name "revision"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map (\x2 -> Model.TermLiteral (Model.LiteralString x2)) opt)) (Format.generationRevision x))}, + Model.Field { + Model.fieldName = (Model.Name "timestamp"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map (\x2 -> Model.TermLiteral (Model.LiteralString x2)) opt)) (Format.generationTimestamp x))}]}) + +-- | Encoder for hydra.build.format.GenerationMode +generationMode :: Format.GenerationMode -> Model.Term +generationMode x = + case x of + Format.GenerationModePublished -> Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.GenerationMode"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "published"), + Model.fieldTerm = Model.TermUnit}}) + Format.GenerationModeShim -> Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.GenerationMode"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "shim"), + Model.fieldTerm = Model.TermUnit}}) + +-- | Encoder for hydra.build.format.HostOverride +hostOverride :: Format.HostOverride -> Model.Term +hostOverride x = + case x of + Format.HostOverrideLocal -> Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.HostOverride"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "local"), + Model.fieldTerm = Model.TermUnit}}) + Format.HostOverrideVersion v0 -> Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.HostOverride"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "version"), + Model.fieldTerm = (Packaging.version v0)}}) + +-- | Encoder for hydra.build.format.InputDigest +inputDigest :: Format.InputDigest -> Model.Term +inputDigest x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.InputDigest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "digestFormatVersion"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) (Format.inputDigestDigestFormatVersion x))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) (Format.inputDigestModuleFormatVersion x))}, + Model.Field { + Model.fieldName = (Model.Name "selfHash"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map sha256Hash opt)) (Format.inputDigestSelfHash x))}, + Model.Field { + Model.fieldName = (Model.Name "dependencyHashes"), + Model.fieldTerm = ((\m -> Model.TermMap (Maps.bimap Packaging.packageName sha256Hash m)) (Format.inputDigestDependencyHashes x))}, + Model.Field { + Model.fieldName = (Model.Name "moduleHashes"), + Model.fieldTerm = ((\m -> Model.TermMap (Maps.bimap Packaging.moduleName sha256Hash m)) (Format.inputDigestModuleHashes x))}]}) + +-- | Encoder for hydra.build.format.LanguageName +languageName :: Format.LanguageName -> Model.Term +languageName x = + Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.build.format.LanguageName"), + Model.wrappedTermBody = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Format.unLanguageName x))}) + +-- | Encoder for hydra.build.format.LanguageProfile +languageProfile :: Format.LanguageProfile -> Model.Term +languageProfile x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.LanguageProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Format.languageProfileName x))}, + Model.Field { + Model.fieldName = (Model.Name "coderPackage"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Format.languageProfileCoderPackage x))}, + Model.Field { + Model.fieldName = (Model.Name "family"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Format.languageProfileFamily x))}]}) + +-- | Encoder for hydra.build.format.ModuleValidationProfile +moduleValidationProfile :: Format.ModuleValidationProfile -> Model.Term +moduleValidationProfile x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "definitions"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map definitionValidationProfile opt)) (Format.moduleValidationProfileDefinitions x))}, + Model.Field { + Model.fieldName = (Model.Name "nameConvention"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map severity opt)) (Format.moduleValidationProfileNameConvention x))}, + Model.Field { + Model.fieldName = (Model.Name "conflictingVariantName"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map severity opt)) (Format.moduleValidationProfileConflictingVariantName x))}]}) + +-- | Encoder for hydra.build.format.OutputDigest +outputDigest :: Format.OutputDigest -> Model.Term +outputDigest x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.OutputDigest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "digestFormatVersion"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) (Format.outputDigestDigestFormatVersion x))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) (Format.outputDigestModuleFormatVersion x))}, + Model.Field { + Model.fieldName = (Model.Name "generator"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Format.outputDigestGenerator x))}, + Model.Field { + Model.fieldName = (Model.Name "generation"), + Model.fieldTerm = (generation (Format.outputDigestGeneration x))}, + Model.Field { + Model.fieldName = (Model.Name "selfHash"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map sha256Hash opt)) (Format.outputDigestSelfHash x))}, + Model.Field { + Model.fieldName = (Model.Name "dependencyHashes"), + Model.fieldTerm = ((\m -> Model.TermMap (Maps.bimap Packaging.packageName sha256Hash m)) (Format.outputDigestDependencyHashes x))}, + Model.Field { + Model.fieldName = (Model.Name "inputs"), + Model.fieldTerm = ((\m -> Model.TermMap (Maps.bimap (\x2 -> Model.TermLiteral (Model.LiteralString x2)) digestEntry m)) (Format.outputDigestInputs x))}, + Model.Field { + Model.fieldName = (Model.Name "outputs"), + Model.fieldTerm = ((\m -> Model.TermMap (Maps.bimap (\x2 -> Model.TermLiteral (Model.LiteralString x2)) digestEntry m)) (Format.outputDigestOutputs x))}]}) + +-- | Encoder for hydra.build.format.PackageDescriptor +packageDescriptor :: Format.PackageDescriptor -> Model.Term +packageDescriptor x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageDescriptor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "packageFormatVersion"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) (Format.packageDescriptorPackageFormatVersion x))}, + Model.Field { + Model.fieldName = (Model.Name "name"), + Model.fieldTerm = (Packaging.packageName (Format.packageDescriptorName x))}, + Model.Field { + Model.fieldName = (Model.Name "description"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Format.packageDescriptorDescription x))}, + Model.Field { + Model.fieldName = (Model.Name "sourceLanguage"), + Model.fieldTerm = (languageName (Format.packageDescriptorSourceLanguage x))}, + Model.Field { + Model.fieldName = (Model.Name "targetLanguages"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map (\xs -> Model.TermList (Lists.map languageName xs)) opt)) (Format.packageDescriptorTargetLanguages x))}, + Model.Field { + Model.fieldName = (Model.Name "dependencies"), + Model.fieldTerm = ((\xs -> Model.TermList (Lists.map Packaging.packageName xs)) (Format.packageDescriptorDependencies x))}, + Model.Field { + Model.fieldName = (Model.Name "validation"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map packageValidationConfiguration opt)) (Format.packageDescriptorValidation x))}]}) + +-- | Encoder for hydra.build.format.PackageManifest +packageManifest :: Format.PackageManifest -> Model.Term +packageManifest x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageManifest"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "manifestFormatVersion"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) (Format.packageManifestManifestFormatVersion x))}, + Model.Field { + Model.fieldName = (Model.Name "moduleFormatVersion"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) (Format.packageManifestModuleFormatVersion x))}, + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = (Packaging.packageName (Format.packageManifestPackage x))}, + Model.Field { + Model.fieldName = (Model.Name "mainModules"), + Model.fieldTerm = ((\xs -> Model.TermList (Lists.map Packaging.moduleName xs)) (Format.packageManifestMainModules x))}, + Model.Field { + Model.fieldName = (Model.Name "testModules"), + Model.fieldTerm = ((\xs -> Model.TermList (Lists.map Packaging.moduleName xs)) (Format.packageManifestTestModules x))}, + Model.Field { + Model.fieldName = (Model.Name "mainDslModules"), + Model.fieldTerm = ((\xs -> Model.TermList (Lists.map Packaging.moduleName xs)) (Format.packageManifestMainDslModules x))}, + Model.Field { + Model.fieldName = (Model.Name "mainEncodingModules"), + Model.fieldTerm = ((\xs -> Model.TermList (Lists.map Packaging.moduleName xs)) (Format.packageManifestMainEncodingModules x))}]}) + +-- | Encoder for hydra.build.format.PackageValidationConfiguration +packageValidationConfiguration :: Format.PackageValidationConfiguration -> Model.Term +packageValidationConfiguration x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "package"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map packageValidationProfile opt)) (Format.packageValidationConfigurationPackage x))}, + Model.Field { + Model.fieldName = (Model.Name "module"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map moduleValidationProfile opt)) (Format.packageValidationConfigurationModule x))}, + Model.Field { + Model.fieldName = (Model.Name "type"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map typeValidationProfile opt)) (Format.packageValidationConfigurationType x))}, + Model.Field { + Model.fieldName = (Model.Name "term"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map termValidationProfile opt)) (Format.packageValidationConfigurationTerm x))}]}) + +-- | Encoder for hydra.build.format.PackageValidationProfile +packageValidationProfile :: Format.PackageValidationProfile -> Model.Term +packageValidationProfile x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "conflictingModuleName"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map severity opt)) (Format.packageValidationProfileConflictingModuleName x))}, + Model.Field { + Model.fieldName = (Model.Name "duplicateModuleName"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map severity opt)) (Format.packageValidationProfileDuplicateModuleName x))}, + Model.Field { + Model.fieldName = (Model.Name "nameConvention"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map severity opt)) (Format.packageValidationProfileNameConvention x))}]}) + +-- | Encoder for hydra.build.format.RepositoryDescriptor +repositoryDescriptor :: Format.RepositoryDescriptor -> Model.Term +repositoryDescriptor x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "currentVersion"), + Model.fieldTerm = (Packaging.version (Format.repositoryDescriptorCurrentVersion x))}, + Model.Field { + Model.fieldName = (Model.Name "hostVersion"), + Model.fieldTerm = (Packaging.version (Format.repositoryDescriptorHostVersion x))}, + Model.Field { + Model.fieldName = (Model.Name "hostOverrides"), + Model.fieldTerm = ((\m -> Model.TermMap (Maps.bimap languageName hostOverride m)) (Format.repositoryDescriptorHostOverrides x))}, + Model.Field { + Model.fieldName = (Model.Name "group"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Format.repositoryDescriptorGroup x))}, + Model.Field { + Model.fieldName = (Model.Name "author"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Format.repositoryDescriptorAuthor x))}, + Model.Field { + Model.fieldName = (Model.Name "url"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Format.repositoryDescriptorUrl x))}, + Model.Field { + Model.fieldName = (Model.Name "license"), + Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Format.repositoryDescriptorLicense x))}, + Model.Field { + Model.fieldName = (Model.Name "packages"), + Model.fieldTerm = ((\xs -> Model.TermList (Lists.map Packaging.packageName xs)) (Format.repositoryDescriptorPackages x))}]}) + +-- | Encoder for hydra.build.format.Severity +severity :: Format.Severity -> Model.Term +severity x = + case x of + Format.SeverityError -> Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.Severity"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "error"), + Model.fieldTerm = Model.TermUnit}}) + Format.SeverityWarning -> Model.TermInject (Model.Injection { + Model.injectionTypeName = (Model.Name "hydra.build.format.Severity"), + Model.injectionField = Model.Field { + Model.fieldName = (Model.Name "warning"), + Model.fieldTerm = Model.TermUnit}}) + +-- | Encoder for hydra.build.format.Sha256Hash +sha256Hash :: Format.Sha256Hash -> Model.Term +sha256Hash x = + Model.TermWrap (Model.WrappedTerm { + Model.wrappedTermTypeName = (Model.Name "hydra.build.format.Sha256Hash"), + Model.wrappedTermBody = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Format.unSha256Hash x))}) + +-- | Encoder for hydra.build.format.TermValidationProfile +termValidationProfile :: Format.TermValidationProfile -> Model.Term +termValidationProfile x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.TermValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "duplicateBinding"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map severity opt)) (Format.termValidationProfileDuplicateBinding x))}, + Model.Field { + Model.fieldName = (Model.Name "emptyTermAnnotation"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map severity opt)) (Format.termValidationProfileEmptyTermAnnotation x))}, + Model.Field { + Model.fieldName = (Model.Name "undefinedVariable"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map severity opt)) (Format.termValidationProfileUndefinedVariable x))}]}) + +-- | Encoder for hydra.build.format.TypeValidationProfile +typeValidationProfile :: Format.TypeValidationProfile -> Model.Term +typeValidationProfile x = + Model.TermRecord (Model.Record { + Model.recordTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"), + Model.recordFields = [ + Model.Field { + Model.fieldName = (Model.Name "emptyAnnotation"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map severity opt)) (Format.typeValidationProfileEmptyAnnotation x))}, + Model.Field { + Model.fieldName = (Model.Name "duplicateField"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map severity opt)) (Format.typeValidationProfileDuplicateField x))}, + Model.Field { + Model.fieldName = (Model.Name "singleVariantUnion"), + Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map severity opt)) (Format.typeValidationProfileSingleVariantUnion x))}]}) diff --git a/src/main/haskell/Hydra/Build/Format.hs b/src/main/haskell/Hydra/Build/Format.hs --- a/src/main/haskell/Hydra/Build/Format.hs +++ b/src/main/haskell/Hydra/Build/Format.hs @@ -1,11 +1,11 @@ -- Note: this is an automatically generated file. Do not edit. --- | Type-level specifications of the JSON formats used by Hydra's build system: the repository descriptor (hydra.json), per-package descriptors (package.json), per-source-set input and output digests (digest.json), generated-source manifests (manifest.json), and per-package validation configuration. Each on-disk file is the canonical JSON encoding of the corresponding type. Overlay build configuration (overlay///build.json) is specified separately, by hydra.gradle and hydra.python.pyproject. See https://github.com/CategoricalData/hydra/issues/512 +-- | Type-level specifications of the JSON formats used by Hydra's build system: the repository descriptor (hydra.json), per-package descriptors (package.json), per-source-set input and output digests (digest.json), generated-source manifests (manifest.json), and per-package validation configuration. Each on-disk file is the canonical JSON encoding of the corresponding type. Overlay build configuration (overlay///build.json) is specified separately, by hydra.java.gradle and hydra.python.pyproject. See https://github.com/CategoricalData/hydra/issues/512 module Hydra.Build.Format where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void @@ -20,11 +20,11 @@ definitionNameConventionProfileAllowUnderscores :: Bool} deriving (Eq, Ord, Read, Show) -_DefinitionNameConventionProfile = Core.Name "hydra.build.format.DefinitionNameConventionProfile" +_DefinitionNameConventionProfile = Model.Name "hydra.build.format.DefinitionNameConventionProfile" -_DefinitionNameConventionProfile_severity = Core.Name "severity" +_DefinitionNameConventionProfile_severity = Model.Name "severity" -_DefinitionNameConventionProfile_allowUnderscores = Core.Name "allowUnderscores" +_DefinitionNameConventionProfile_allowUnderscores = Model.Name "allowUnderscores" -- | Validation rules applying to individual definitions within a module. Absent fields mean the corresponding check is not configured. data DefinitionValidationProfile = @@ -41,17 +41,17 @@ definitionValidationProfileDuplicateName :: (Maybe Severity)} deriving (Eq, Ord, Read, Show) -_DefinitionValidationProfile = Core.Name "hydra.build.format.DefinitionValidationProfile" +_DefinitionValidationProfile = Model.Name "hydra.build.format.DefinitionValidationProfile" -_DefinitionValidationProfile_hasDescription = Core.Name "hasDescription" +_DefinitionValidationProfile_hasDescription = Model.Name "hasDescription" -_DefinitionValidationProfile_ordering = Core.Name "ordering" +_DefinitionValidationProfile_ordering = Model.Name "ordering" -_DefinitionValidationProfile_nameConvention = Core.Name "nameConvention" +_DefinitionValidationProfile_nameConvention = Model.Name "nameConvention" -_DefinitionValidationProfile_notInModuleName = Core.Name "notInModuleName" +_DefinitionValidationProfile_notInModuleName = Model.Name "notInModuleName" -_DefinitionValidationProfile_duplicateName = Core.Name "duplicateName" +_DefinitionValidationProfile_duplicateName = Model.Name "duplicateName" -- | One file's classification and content hash within a digest data DigestEntry = @@ -62,11 +62,11 @@ digestEntryHash :: Sha256Hash} deriving (Eq, Ord, Read, Show) -_DigestEntry = Core.Name "hydra.build.format.DigestEntry" +_DigestEntry = Model.Name "hydra.build.format.DigestEntry" -_DigestEntry_kind = Core.Name "kind" +_DigestEntry_kind = Model.Name "kind" -_DigestEntry_hash = Core.Name "hash" +_DigestEntry_hash = Model.Name "hash" -- | The kind of artifact recorded in a digest entry. Lets a single digest mix typed entries without losing the discriminator. data DigestKind = @@ -82,17 +82,17 @@ DigestKindOther deriving (Eq, Ord, Read, Show) -_DigestKind = Core.Name "hydra.build.format.DigestKind" +_DigestKind = Model.Name "hydra.build.format.DigestKind" -_DigestKind_dslSource = Core.Name "dslSource" +_DigestKind_dslSource = Model.Name "dslSource" -_DigestKind_jsonFile = Core.Name "jsonFile" +_DigestKind_jsonFile = Model.Name "jsonFile" -_DigestKind_targetFile = Core.Name "targetFile" +_DigestKind_targetFile = Model.Name "targetFile" -_DigestKind_runtimeFile = Core.Name "runtimeFile" +_DigestKind_runtimeFile = Model.Name "runtimeFile" -_DigestKind_other = Core.Name "other" +_DigestKind_other = Model.Name "other" -- | Configuration for the definition-documentation check data DocumentationProfile = @@ -103,11 +103,11 @@ documentationProfileExemptDeprecated :: Bool} deriving (Eq, Ord, Read, Show) -_DocumentationProfile = Core.Name "hydra.build.format.DocumentationProfile" +_DocumentationProfile = Model.Name "hydra.build.format.DocumentationProfile" -_DocumentationProfile_severity = Core.Name "severity" +_DocumentationProfile_severity = Model.Name "severity" -_DocumentationProfile_exemptDeprecated = Core.Name "exemptDeprecated" +_DocumentationProfile_exemptDeprecated = Model.Name "exemptDeprecated" -- | A structured generation-provenance record for generated artifacts, separating gating identity from informational provenance. Only generatorId gates cache freshness; it is host-independent by design, since self-hosting requires every host to produce byte-identical output. All other fields are informational and must not gate. Invariant: a shim-mode generation has a revision (a shim has no release version, so the working-tree revision is its only precise identity). data Generation = @@ -126,19 +126,19 @@ generationTimestamp :: (Maybe String)} deriving (Eq, Ord, Read, Show) -_Generation = Core.Name "hydra.build.format.Generation" +_Generation = Model.Name "hydra.build.format.Generation" -_Generation_generatorId = Core.Name "generatorId" +_Generation_generatorId = Model.Name "generatorId" -_Generation_mode = Core.Name "mode" +_Generation_mode = Model.Name "mode" -_Generation_host = Core.Name "host" +_Generation_host = Model.Name "host" -_Generation_hydraVersion = Core.Name "hydraVersion" +_Generation_hydraVersion = Model.Name "hydraVersion" -_Generation_revision = Core.Name "revision" +_Generation_revision = Model.Name "revision" -_Generation_timestamp = Core.Name "timestamp" +_Generation_timestamp = Model.Name "timestamp" -- | The provenance class of a generated artifact data GenerationMode = @@ -148,11 +148,11 @@ GenerationModeShim deriving (Eq, Ord, Read, Show) -_GenerationMode = Core.Name "hydra.build.format.GenerationMode" +_GenerationMode = Model.Name "hydra.build.format.GenerationMode" -_GenerationMode_published = Core.Name "published" +_GenerationMode_published = Model.Name "published" -_GenerationMode_shim = Core.Name "shim" +_GenerationMode_shim = Model.Name "shim" -- | An override of the default published-host consumption for one host language: either force a local from-source build, or pin a specific published version. data HostOverride = @@ -162,11 +162,11 @@ HostOverrideVersion Packaging.Version deriving (Eq, Ord, Read, Show) -_HostOverride = Core.Name "hydra.build.format.HostOverride" +_HostOverride = Model.Name "hydra.build.format.HostOverride" -_HostOverride_local = Core.Name "local" +_HostOverride_local = Model.Name "local" -_HostOverride_version = Core.Name "version" +_HostOverride_version = Model.Name "version" -- | A per-package, per-source-set input digest (dist/json//build//digest.json): Merkle-style hashes of the package's DSL sources, recorded when the package's JSON is written and consumed by downstream freshness checks. The selfHash summarizes the package's own module hashes; dependencyHashes captures the selfHash of each declared dependency package at write time, giving transitive invalidation. data InputDigest = @@ -183,17 +183,17 @@ inputDigestModuleHashes :: (M.Map Packaging.ModuleName Sha256Hash)} deriving (Eq, Ord, Read, Show) -_InputDigest = Core.Name "hydra.build.format.InputDigest" +_InputDigest = Model.Name "hydra.build.format.InputDigest" -_InputDigest_digestFormatVersion = Core.Name "digestFormatVersion" +_InputDigest_digestFormatVersion = Model.Name "digestFormatVersion" -_InputDigest_moduleFormatVersion = Core.Name "moduleFormatVersion" +_InputDigest_moduleFormatVersion = Model.Name "moduleFormatVersion" -_InputDigest_selfHash = Core.Name "selfHash" +_InputDigest_selfHash = Model.Name "selfHash" -_InputDigest_dependencyHashes = Core.Name "dependencyHashes" +_InputDigest_dependencyHashes = Model.Name "dependencyHashes" -_InputDigest_moduleHashes = Core.Name "moduleHashes" +_InputDigest_moduleHashes = Model.Name "moduleHashes" -- | The name of a source or target language in Hydra's build system, e.g. "haskell", "java", or "python" newtype LanguageName = @@ -201,7 +201,7 @@ unLanguageName :: String} deriving (Eq, Ord, Read, Show) -_LanguageName = Core.Name "hydra.build.format.LanguageName" +_LanguageName = Model.Name "hydra.build.format.LanguageName" -- | The build identity of a source/target language: how the build system treats it. See https://github.com/CategoricalData/hydra/issues/559 data LanguageProfile = @@ -214,13 +214,13 @@ languageProfileFamily :: String} deriving (Eq, Ord, Read, Show) -_LanguageProfile = Core.Name "hydra.build.format.LanguageProfile" +_LanguageProfile = Model.Name "hydra.build.format.LanguageProfile" -_LanguageProfile_name = Core.Name "name" +_LanguageProfile_name = Model.Name "name" -_LanguageProfile_coderPackage = Core.Name "coderPackage" +_LanguageProfile_coderPackage = Model.Name "coderPackage" -_LanguageProfile_family = Core.Name "family" +_LanguageProfile_family = Model.Name "family" -- | Validation rules applying to a module as a whole. Absent fields mean the corresponding check is not configured. data ModuleValidationProfile = @@ -233,13 +233,13 @@ moduleValidationProfileConflictingVariantName :: (Maybe Severity)} deriving (Eq, Ord, Read, Show) -_ModuleValidationProfile = Core.Name "hydra.build.format.ModuleValidationProfile" +_ModuleValidationProfile = Model.Name "hydra.build.format.ModuleValidationProfile" -_ModuleValidationProfile_definitions = Core.Name "definitions" +_ModuleValidationProfile_definitions = Model.Name "definitions" -_ModuleValidationProfile_nameConvention = Core.Name "nameConvention" +_ModuleValidationProfile_nameConvention = Model.Name "nameConvention" -_ModuleValidationProfile_conflictingVariantName = Core.Name "conflictingVariantName" +_ModuleValidationProfile_conflictingVariantName = Model.Name "conflictingVariantName" -- | A per-package, per-source-set output digest for one target language (dist///build//digest.json), recording every input file whose content determines the generated output, every output file the generation step is responsible for, and the identity of the generator. A generation step is fresh exactly when all input hashes, all output hashes, the generator identity, and the recorded package and dependency hashes match. data OutputDigest = @@ -262,23 +262,23 @@ outputDigestOutputs :: (M.Map String DigestEntry)} deriving (Eq, Ord, Read, Show) -_OutputDigest = Core.Name "hydra.build.format.OutputDigest" +_OutputDigest = Model.Name "hydra.build.format.OutputDigest" -_OutputDigest_digestFormatVersion = Core.Name "digestFormatVersion" +_OutputDigest_digestFormatVersion = Model.Name "digestFormatVersion" -_OutputDigest_moduleFormatVersion = Core.Name "moduleFormatVersion" +_OutputDigest_moduleFormatVersion = Model.Name "moduleFormatVersion" -_OutputDigest_generator = Core.Name "generator" +_OutputDigest_generator = Model.Name "generator" -_OutputDigest_generation = Core.Name "generation" +_OutputDigest_generation = Model.Name "generation" -_OutputDigest_selfHash = Core.Name "selfHash" +_OutputDigest_selfHash = Model.Name "selfHash" -_OutputDigest_dependencyHashes = Core.Name "dependencyHashes" +_OutputDigest_dependencyHashes = Model.Name "dependencyHashes" -_OutputDigest_inputs = Core.Name "inputs" +_OutputDigest_inputs = Model.Name "inputs" -_OutputDigest_outputs = Core.Name "outputs" +_OutputDigest_outputs = Model.Name "outputs" -- | A package descriptor (packages//package.json): the source-of-truth declaration of a Hydra package's name, source language, dependencies, and optional per-package configuration. data PackageDescriptor = @@ -299,21 +299,21 @@ packageDescriptorValidation :: (Maybe PackageValidationConfiguration)} deriving (Eq, Ord, Read, Show) -_PackageDescriptor = Core.Name "hydra.build.format.PackageDescriptor" +_PackageDescriptor = Model.Name "hydra.build.format.PackageDescriptor" -_PackageDescriptor_packageFormatVersion = Core.Name "packageFormatVersion" +_PackageDescriptor_packageFormatVersion = Model.Name "packageFormatVersion" -_PackageDescriptor_name = Core.Name "name" +_PackageDescriptor_name = Model.Name "name" -_PackageDescriptor_description = Core.Name "description" +_PackageDescriptor_description = Model.Name "description" -_PackageDescriptor_sourceLanguage = Core.Name "sourceLanguage" +_PackageDescriptor_sourceLanguage = Model.Name "sourceLanguage" -_PackageDescriptor_targetLanguages = Core.Name "targetLanguages" +_PackageDescriptor_targetLanguages = Model.Name "targetLanguages" -_PackageDescriptor_dependencies = Core.Name "dependencies" +_PackageDescriptor_dependencies = Model.Name "dependencies" -_PackageDescriptor_validation = Core.Name "validation" +_PackageDescriptor_validation = Model.Name "validation" -- | A generated-source manifest (dist///src///manifest.json): the list of modules generated into a distribution package, partitioned by role. data PackageManifest = @@ -334,21 +334,21 @@ packageManifestMainEncodingModules :: [Packaging.ModuleName]} deriving (Eq, Ord, Read, Show) -_PackageManifest = Core.Name "hydra.build.format.PackageManifest" +_PackageManifest = Model.Name "hydra.build.format.PackageManifest" -_PackageManifest_manifestFormatVersion = Core.Name "manifestFormatVersion" +_PackageManifest_manifestFormatVersion = Model.Name "manifestFormatVersion" -_PackageManifest_moduleFormatVersion = Core.Name "moduleFormatVersion" +_PackageManifest_moduleFormatVersion = Model.Name "moduleFormatVersion" -_PackageManifest_package = Core.Name "package" +_PackageManifest_package = Model.Name "package" -_PackageManifest_mainModules = Core.Name "mainModules" +_PackageManifest_mainModules = Model.Name "mainModules" -_PackageManifest_testModules = Core.Name "testModules" +_PackageManifest_testModules = Model.Name "testModules" -_PackageManifest_mainDslModules = Core.Name "mainDslModules" +_PackageManifest_mainDslModules = Model.Name "mainDslModules" -_PackageManifest_mainEncodingModules = Core.Name "mainEncodingModules" +_PackageManifest_mainEncodingModules = Model.Name "mainEncodingModules" -- | The full, opt-in validation configuration for a package, as declared in its package descriptor. Every field cascades optional; an absent field means the corresponding rule family is not configured and the validation engine's defaults apply. data PackageValidationConfiguration = @@ -363,15 +363,15 @@ packageValidationConfigurationTerm :: (Maybe TermValidationProfile)} deriving (Eq, Ord, Read, Show) -_PackageValidationConfiguration = Core.Name "hydra.build.format.PackageValidationConfiguration" +_PackageValidationConfiguration = Model.Name "hydra.build.format.PackageValidationConfiguration" -_PackageValidationConfiguration_package = Core.Name "package" +_PackageValidationConfiguration_package = Model.Name "package" -_PackageValidationConfiguration_module = Core.Name "module" +_PackageValidationConfiguration_module = Model.Name "module" -_PackageValidationConfiguration_type = Core.Name "type" +_PackageValidationConfiguration_type = Model.Name "type" -_PackageValidationConfiguration_term = Core.Name "term" +_PackageValidationConfiguration_term = Model.Name "term" -- | Validation rules applying to a package as a whole. Absent fields mean the corresponding check is not configured. data PackageValidationProfile = @@ -384,13 +384,13 @@ packageValidationProfileNameConvention :: (Maybe Severity)} deriving (Eq, Ord, Read, Show) -_PackageValidationProfile = Core.Name "hydra.build.format.PackageValidationProfile" +_PackageValidationProfile = Model.Name "hydra.build.format.PackageValidationProfile" -_PackageValidationProfile_conflictingModuleName = Core.Name "conflictingModuleName" +_PackageValidationProfile_conflictingModuleName = Model.Name "conflictingModuleName" -_PackageValidationProfile_duplicateModuleName = Core.Name "duplicateModuleName" +_PackageValidationProfile_duplicateModuleName = Model.Name "duplicateModuleName" -_PackageValidationProfile_nameConvention = Core.Name "nameConvention" +_PackageValidationProfile_nameConvention = Model.Name "nameConvention" -- | The repository descriptor (hydra.json at the repository root): release and host versions, host consumption overrides, publication metadata, and the list of source packages. data RepositoryDescriptor = @@ -413,23 +413,23 @@ repositoryDescriptorPackages :: [Packaging.PackageName]} deriving (Eq, Ord, Read, Show) -_RepositoryDescriptor = Core.Name "hydra.build.format.RepositoryDescriptor" +_RepositoryDescriptor = Model.Name "hydra.build.format.RepositoryDescriptor" -_RepositoryDescriptor_currentVersion = Core.Name "currentVersion" +_RepositoryDescriptor_currentVersion = Model.Name "currentVersion" -_RepositoryDescriptor_hostVersion = Core.Name "hostVersion" +_RepositoryDescriptor_hostVersion = Model.Name "hostVersion" -_RepositoryDescriptor_hostOverrides = Core.Name "hostOverrides" +_RepositoryDescriptor_hostOverrides = Model.Name "hostOverrides" -_RepositoryDescriptor_group = Core.Name "group" +_RepositoryDescriptor_group = Model.Name "group" -_RepositoryDescriptor_author = Core.Name "author" +_RepositoryDescriptor_author = Model.Name "author" -_RepositoryDescriptor_url = Core.Name "url" +_RepositoryDescriptor_url = Model.Name "url" -_RepositoryDescriptor_license = Core.Name "license" +_RepositoryDescriptor_license = Model.Name "license" -_RepositoryDescriptor_packages = Core.Name "packages" +_RepositoryDescriptor_packages = Model.Name "packages" -- | How a validation finding is treated data Severity = @@ -437,11 +437,11 @@ SeverityWarning deriving (Eq, Ord, Read, Show) -_Severity = Core.Name "hydra.build.format.Severity" +_Severity = Model.Name "hydra.build.format.Severity" -_Severity_error = Core.Name "error" +_Severity_error = Model.Name "error" -_Severity_warning = Core.Name "warning" +_Severity_warning = Model.Name "warning" -- | A SHA-256 hash in lowercase hexadecimal notation newtype Sha256Hash = @@ -449,7 +449,7 @@ unSha256Hash :: String} deriving (Eq, Ord, Read, Show) -_Sha256Hash = Core.Name "hydra.build.format.Sha256Hash" +_Sha256Hash = Model.Name "hydra.build.format.Sha256Hash" -- | Validation rules applying to term-definition bodies. Absent fields mean the corresponding check is not configured. data TermValidationProfile = @@ -462,13 +462,13 @@ termValidationProfileUndefinedVariable :: (Maybe Severity)} deriving (Eq, Ord, Read, Show) -_TermValidationProfile = Core.Name "hydra.build.format.TermValidationProfile" +_TermValidationProfile = Model.Name "hydra.build.format.TermValidationProfile" -_TermValidationProfile_duplicateBinding = Core.Name "duplicateBinding" +_TermValidationProfile_duplicateBinding = Model.Name "duplicateBinding" -_TermValidationProfile_emptyTermAnnotation = Core.Name "emptyTermAnnotation" +_TermValidationProfile_emptyTermAnnotation = Model.Name "emptyTermAnnotation" -_TermValidationProfile_undefinedVariable = Core.Name "undefinedVariable" +_TermValidationProfile_undefinedVariable = Model.Name "undefinedVariable" -- | Validation rules applying to type-definition bodies. Absent fields mean the corresponding check is not configured. data TypeValidationProfile = @@ -481,10 +481,10 @@ typeValidationProfileSingleVariantUnion :: (Maybe Severity)} deriving (Eq, Ord, Read, Show) -_TypeValidationProfile = Core.Name "hydra.build.format.TypeValidationProfile" +_TypeValidationProfile = Model.Name "hydra.build.format.TypeValidationProfile" -_TypeValidationProfile_emptyAnnotation = Core.Name "emptyAnnotation" +_TypeValidationProfile_emptyAnnotation = Model.Name "emptyAnnotation" -_TypeValidationProfile_duplicateField = Core.Name "duplicateField" +_TypeValidationProfile_duplicateField = Model.Name "duplicateField" -_TypeValidationProfile_singleVariantUnion = Core.Name "singleVariantUnion" +_TypeValidationProfile_singleVariantUnion = Model.Name "singleVariantUnion" diff --git a/src/main/haskell/Hydra/Build/Langexpansion.hs b/src/main/haskell/Hydra/Build/Langexpansion.hs --- a/src/main/haskell/Hydra/Build/Langexpansion.hs +++ b/src/main/haskell/Hydra/Build/Langexpansion.hs @@ -4,40 +4,42 @@ module Hydra.Build.Langexpansion where -import qualified Hydra.Ast as Ast import qualified Hydra.Build.Registry as Registry -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.Equality as Equality -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic -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.Regex as Regex -import qualified Hydra.Relational as Relational -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 qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Strip as Strip +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void diff --git a/src/main/haskell/Hydra/Build/Libraries.hs b/src/main/haskell/Hydra/Build/Libraries.hs --- a/src/main/haskell/Hydra/Build/Libraries.hs +++ b/src/main/haskell/Hydra/Build/Libraries.hs @@ -4,36 +4,38 @@ module Hydra.Build.Libraries 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.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -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.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void diff --git a/src/main/haskell/Hydra/Build/ManifestWriter.hs b/src/main/haskell/Hydra/Build/ManifestWriter.hs --- a/src/main/haskell/Hydra/Build/ManifestWriter.hs +++ b/src/main/haskell/Hydra/Build/ManifestWriter.hs @@ -4,55 +4,57 @@ module Hydra.Build.ManifestWriter 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.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.Regex as Regex -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.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Literals as Literals +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void -- | The manifest.json contents for one package: field assembly + serialization, given the package name and its main/dsl/encoding/test module lists -packageManifestJson :: String -> [Packaging.Module] -> [Packaging.Module] -> [Packaging.Module] -> [Packaging.Module] -> Model.Value +packageManifestJson :: String -> [Packaging.Module] -> [Packaging.Module] -> [Packaging.Module] -> [Packaging.Module] -> JsonModel.Value packageManifestJson pkg mainMods dslMods encMods testMods = - Model.ValueObject [ + JsonModel.ValueObject [ ("mainDslModules", (sortedNamespaces dslMods)), ("mainEncodingModules", (sortedNamespaces encMods)), ("mainModules", (sortedNamespaces mainMods)), - ("manifestFormatVersion", (Model.ValueNumber (Literals.bigintToDecimal 1))), - ("package", (Model.ValueString pkg)), + ("manifestFormatVersion", (JsonModel.ValueNumber (Literals.bigintToDecimal 1))), + ("package", (JsonModel.ValueString pkg)), ("testModules", (sortedNamespaces testMods))] -- | The sorted namespace strings of a list of modules, as a JSON string array -sortedNamespaces :: [Packaging.Module] -> Model.Value +sortedNamespaces :: [Packaging.Module] -> JsonModel.Value sortedNamespaces mods = let names = Lists.sort (Lists.map (\m -> Packaging.unModuleName (Packaging.moduleName m)) mods) - in (Model.ValueArray (Lists.map (\n -> Model.ValueString n) names)) + in (JsonModel.ValueArray (Lists.map (\n -> JsonModel.ValueString n) names)) diff --git a/src/main/haskell/Hydra/Build/Modules.hs b/src/main/haskell/Hydra/Build/Modules.hs --- a/src/main/haskell/Hydra/Build/Modules.hs +++ b/src/main/haskell/Hydra/Build/Modules.hs @@ -4,42 +4,44 @@ module Hydra.Build.Modules 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.Logic as Logic -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Ordering as Ordering -import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -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 qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Ordering as Ordering +import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Strip as Strip +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void @@ -48,7 +50,7 @@ dedupPreservingOrder :: Eq t0 => ([t0] -> [t0]) dedupPreservingOrder xs = Lists.distinct xs --- | Keep only modules outside the hydra.* and hydra.json.yaml.* namespaces +-- | Keep only modules outside the hydra.* and hydra.core.json.yaml.* namespaces filterKernelModules :: [Packaging.Module] -> [Packaging.Module] filterKernelModules mods = @@ -58,7 +60,7 @@ in (Optionals.match (Lists.uncons parts) False (\uc -> Logic.and (Strings.isEmpty (Pairs.first uc)) (Logic.not (Lists.isEmpty (Pairs.second uc))))) in (Lists.filter (\m -> let name = Packaging.unModuleName (Packaging.moduleName m) - in (Logic.and (Logic.not (startsWith "hydra." name)) (Logic.not (startsWith "hydra.json.yaml." name)))) mods) + in (Logic.and (Logic.not (startsWith "hydra." name)) (Logic.not (startsWith "hydra.core.json.yaml." name)))) mods) -- | Keep only modules containing at least one type-defining binding filterTypeModules :: [Packaging.Module] -> [Packaging.Module] diff --git a/src/main/haskell/Hydra/Build/PackagingProfile.hs b/src/main/haskell/Hydra/Build/PackagingProfile.hs --- a/src/main/haskell/Hydra/Build/PackagingProfile.hs +++ b/src/main/haskell/Hydra/Build/PackagingProfile.hs @@ -4,38 +4,40 @@ module Hydra.Build.PackagingProfile 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.Logic as Logic -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.Regex as Regex -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.Validate.Packaging as ValidatePackaging -import qualified Hydra.Validation as Validation -import qualified Hydra.Variants as Variants +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validate.Packaging as ValidatePackaging +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void diff --git a/src/main/haskell/Hydra/Build/Publishsets.hs b/src/main/haskell/Hydra/Build/Publishsets.hs --- a/src/main/haskell/Hydra/Build/Publishsets.hs +++ b/src/main/haskell/Hydra/Build/Publishsets.hs @@ -4,41 +4,43 @@ module Hydra.Build.Publishsets 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.Eithers as Eithers -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic -import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -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.Variants as Variants +import qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Sorting as Sorting +import qualified Hydra.Core.Strip as Strip +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void diff --git a/src/main/haskell/Hydra/Build/Reconcile.hs b/src/main/haskell/Hydra/Build/Reconcile.hs --- a/src/main/haskell/Hydra/Build/Reconcile.hs +++ b/src/main/haskell/Hydra/Build/Reconcile.hs @@ -4,43 +4,45 @@ module Hydra.Build.Reconcile where -import qualified Hydra.Ast as Ast -import qualified Hydra.Codegen as Codegen -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.Equality as Equality -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Ordering as Ordering -import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -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.Core.Ast as Ast +import qualified Hydra.Core.Codegen as Codegen +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Ordering as Ordering +import qualified Hydra.Core.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void diff --git a/src/main/haskell/Hydra/Build/Registry.hs b/src/main/haskell/Hydra/Build/Registry.hs --- a/src/main/haskell/Hydra/Build/Registry.hs +++ b/src/main/haskell/Hydra/Build/Registry.hs @@ -4,41 +4,43 @@ module Hydra.Build.Registry where -import qualified Hydra.Ast as Ast import qualified Hydra.Build.Format as Format -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.Equality as Equality -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -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 qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Strip as Strip +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void diff --git a/src/main/haskell/Hydra/Build/Routing.hs b/src/main/haskell/Hydra/Build/Routing.hs --- a/src/main/haskell/Hydra/Build/Routing.hs +++ b/src/main/haskell/Hydra/Build/Routing.hs @@ -4,45 +4,47 @@ module Hydra.Build.Routing where -import qualified Hydra.Ast as Ast -import qualified Hydra.Coders as Coders -import qualified Hydra.Core as Core -import qualified Hydra.Decoding as Decoding -import qualified Hydra.Docs as Docs -import qualified Hydra.Dsls as Dsls -import qualified Hydra.Encoding as Encoding -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.Eithers as Eithers -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.Strings as Strings -import qualified Hydra.Names as Names -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -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.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Decoding as Decoding +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Dsls as Dsls +import qualified Hydra.Core.Encoding as Encoding +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Names as Names +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void diff --git a/src/main/haskell/Hydra/Build/Syncmatrix.hs b/src/main/haskell/Hydra/Build/Syncmatrix.hs --- a/src/main/haskell/Hydra/Build/Syncmatrix.hs +++ b/src/main/haskell/Hydra/Build/Syncmatrix.hs @@ -4,41 +4,43 @@ module Hydra.Build.Syncmatrix where -import qualified Hydra.Ast as Ast import qualified Hydra.Build.Langexpansion as Langexpansion import qualified Hydra.Build.Registry as Registry -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.Equality as Equality -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic -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.Regex as Regex -import qualified Hydra.Relational as Relational -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 qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Strip as Strip +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void diff --git a/src/main/haskell/Hydra/Build/Versionconsistency.hs b/src/main/haskell/Hydra/Build/Versionconsistency.hs --- a/src/main/haskell/Hydra/Build/Versionconsistency.hs +++ b/src/main/haskell/Hydra/Build/Versionconsistency.hs @@ -4,41 +4,43 @@ module Hydra.Build.Versionconsistency 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.Logic as Logic -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Ordering as Ordering -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -import qualified Hydra.Relational as Relational -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 qualified Hydra.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Ordering as Ordering +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.Strip as Strip +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void diff --git a/src/main/haskell/Hydra/Build/Walk.hs b/src/main/haskell/Hydra/Build/Walk.hs --- a/src/main/haskell/Hydra/Build/Walk.hs +++ b/src/main/haskell/Hydra/Build/Walk.hs @@ -4,41 +4,43 @@ module Hydra.Build.Walk 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.Equality as Equality -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic -import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Ordering as Ordering -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Paths as Paths -import qualified Hydra.Query as Query -import qualified Hydra.Regex as Regex -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.Core.Ast as Ast +import qualified Hydra.Core.Coders as Coders +import qualified Hydra.Core.Diff as Diff +import qualified Hydra.Core.Docs as Docs +import qualified Hydra.Core.Error.Checking as Checking +import qualified Hydra.Core.Error.File as ErrorFile +import qualified Hydra.Core.Error.Model as ErrorModel +import qualified Hydra.Core.Error.Packaging as ErrorPackaging +import qualified Hydra.Core.Error.System as ErrorSystem +import qualified Hydra.Core.Errors as Errors +import qualified Hydra.Core.File as File +import qualified Hydra.Core.Graph as Graph +import qualified Hydra.Core.Json.Model as JsonModel +import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Core.Overlay.Haskell.Lib.Ordering as Ordering +import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Core.Markdown as Markdown +import qualified Hydra.Core.Model as Model +import qualified Hydra.Core.Packaging as Packaging +import qualified Hydra.Core.Parsing as Parsing +import qualified Hydra.Core.Paths as Paths +import qualified Hydra.Core.Query as Query +import qualified Hydra.Core.Regex as Regex +import qualified Hydra.Core.Relational as Relational +import qualified Hydra.Core.System as System +import qualified Hydra.Core.Tabular as Tabular +import qualified Hydra.Core.Testing as Testing +import qualified Hydra.Core.Time as Time +import qualified Hydra.Core.Topology as Topology +import qualified Hydra.Core.Typed as Typed +import qualified Hydra.Core.Typing as Typing +import qualified Hydra.Core.Util as Util +import qualified Hydra.Core.Validation as Validation +import qualified Hydra.Core.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void diff --git a/src/main/haskell/Hydra/Decode/Build/Assembly.hs b/src/main/haskell/Hydra/Decode/Build/Assembly.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Decode/Build/Assembly.hs +++ /dev/null @@ -1,102 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.build.assembly - -module Hydra.Decode.Build.Assembly where - -import qualified Hydra.Build.Assembly as Assembly -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Core as ExtractCore -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -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 -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Util as Util -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Decoder for hydra.build.assembly.AssemblyEntry -assemblyEntry :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Assembly.AssemblyEntry -assemblyEntry cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "sourceTree" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_sourceTree -> Eithers.bind (ExtractCore.requireField "destTree" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_destTree -> Eithers.bind (ExtractCore.requireField "kind" assemblyEntryKind fieldMap cx) (\field_kind -> Eithers.bind (ExtractCore.requireField "exclude" (ExtractCore.decodeList (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_exclude -> Right (Assembly.AssemblyEntry { - Assembly.assemblyEntrySourceTree = field_sourceTree, - Assembly.assemblyEntryDestTree = field_destTree, - Assembly.assemblyEntryKind = field_kind, - Assembly.assemblyEntryExclude = field_exclude})))))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.assembly.AssemblyEntry")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.assembly.AssemblyEntryKind -assemblyEntryKind :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Assembly.AssemblyEntryKind -assemblyEntryKind cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermInject v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "merge", (\input -> Eithers.map (\t -> Assembly.AssemblyEntryKindMerge) (ExtractCore.decodeUnit cx input))), - ( - Core.Name "wipeThenCopy", - (\input -> Eithers.map (\t -> Assembly.AssemblyEntryKindWipeThenCopy) (ExtractCore.decodeUnit cx input))), - ( - Core.Name "symlinkTree", - (\input -> Eithers.map (\t -> Assembly.AssemblyEntryKindSymlinkTree) (ExtractCore.decodeUnit cx input))), - ( - Core.Name "symlinkDir", - (\input -> Eithers.map (\t -> Assembly.AssemblyEntryKindSymlinkDir) (ExtractCore.decodeUnit cx input)))] - in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm)) - _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.assembly.AssemblyPlan -assemblyPlan :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Assembly.AssemblyPlan -assemblyPlan cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "entries" (ExtractCore.decodeList assemblyEntry) fieldMap cx) (\field_entries -> Eithers.bind (ExtractCore.requireField "keepPaths" (ExtractCore.decodeList keepPathEntry) fieldMap cx) (\field_keepPaths -> Right (Assembly.AssemblyPlan { - Assembly.assemblyPlanEntries = field_entries, - Assembly.assemblyPlanKeepPaths = field_keepPaths})))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.assembly.AssemblyPlan")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.assembly.KeepPathEntry -keepPathEntry :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Assembly.KeepPathEntry -keepPathEntry cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "sourceSetDir" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_sourceSetDir -> Eithers.bind (ExtractCore.requireField "relPath" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_relPath -> Right (Assembly.KeepPathEntry { - Assembly.keepPathEntrySourceSetDir = field_sourceSetDir, - Assembly.keepPathEntryRelPath = field_relPath})))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.assembly.KeepPathEntry")) (ExtractCore.stripWithDecodingError cx raw) diff --git a/src/main/haskell/Hydra/Decode/Build/Benchresult.hs b/src/main/haskell/Hydra/Decode/Build/Benchresult.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Decode/Build/Benchresult.hs +++ /dev/null @@ -1,123 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.build.benchresult - -module Hydra.Decode.Build.Benchresult where - -import qualified Hydra.Build.Benchresult as Benchresult -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Core as ExtractCore -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Util as Util -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Decoder for hydra.build.benchresult.BenchMetadata -benchMetadata :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Benchresult.BenchMetadata -benchMetadata cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "timestamp" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_timestamp -> Eithers.bind (ExtractCore.requireField "language" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_language -> Eithers.bind (ExtractCore.requireField "branch" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_branch -> Eithers.bind (ExtractCore.requireField "commit" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_commit -> Eithers.bind (ExtractCore.requireField "commitMessage" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_commitMessage -> Right (Benchresult.BenchMetadata { - Benchresult.benchMetadataTimestamp = field_timestamp, - Benchresult.benchMetadataLanguage = field_language, - Benchresult.benchMetadataBranch = field_branch, - Benchresult.benchMetadataCommit = field_commit, - Benchresult.benchMetadataCommitMessage = field_commitMessage}))))))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.benchresult.BenchMetadata")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.benchresult.GenBenchResult -genBenchResult :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Benchresult.GenBenchResult -genBenchResult cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "target" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_target -> Eithers.bind (ExtractCore.requireField "runs" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_runs -> Eithers.bind (ExtractCore.requireField "hosts" (ExtractCore.decodeMap (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) hostResult) fieldMap cx) (\field_hosts -> Eithers.bind (ExtractCore.requireField "metadata" (ExtractCore.decodeMaybe benchMetadata) fieldMap cx) (\field_metadata -> Right (Benchresult.GenBenchResult { - Benchresult.genBenchResultTarget = field_target, - Benchresult.genBenchResultRuns = field_runs, - Benchresult.genBenchResultHosts = field_hosts, - Benchresult.genBenchResultMetadata = field_metadata})))))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.benchresult.GenBenchResult")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.benchresult.HostResult -hostResult :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Benchresult.HostResult -hostResult cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "setupMs" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_setupMs -> Eithers.bind (ExtractCore.requireField "packages" (ExtractCore.decodeMap (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) runStats) fieldMap cx) (\field_packages -> Right (Benchresult.HostResult { - Benchresult.hostResultSetupMs = field_setupMs, - Benchresult.hostResultPackages = field_packages})))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.benchresult.HostResult")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.benchresult.RunStats -runStats :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Benchresult.RunStats -runStats cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "runsMs" (ExtractCore.decodeList (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_runsMs -> Eithers.bind (ExtractCore.requireField "medianMs" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_medianMs -> Right (Benchresult.RunStats { - Benchresult.runStatsRunsMs = field_runsMs, - Benchresult.runStatsMedianMs = field_medianMs})))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.benchresult.RunStats")) (ExtractCore.stripWithDecodingError cx raw) diff --git a/src/main/haskell/Hydra/Decode/Build/Comparereport.hs b/src/main/haskell/Hydra/Decode/Build/Comparereport.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Decode/Build/Comparereport.hs +++ /dev/null @@ -1,102 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.build.comparereport - -module Hydra.Decode.Build.Comparereport where - -import qualified Hydra.Build.Comparereport as Comparereport -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Core as ExtractCore -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -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 -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Util as Util -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Decoder for hydra.build.comparereport.CompareReport -compareReport :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Comparereport.CompareReport -compareReport cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "rows" (ExtractCore.decodeList moduleCompare) fieldMap cx) (\field_rows -> Eithers.bind (ExtractCore.requireField "byteEqCount" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_byteEqCount -> Eithers.bind (ExtractCore.requireField "total" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_total -> Right (Comparereport.CompareReport { - Comparereport.compareReportRows = field_rows, - Comparereport.compareReportByteEqCount = field_byteEqCount, - Comparereport.compareReportTotal = field_total}))))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.comparereport.CompareReport")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.comparereport.CompareStatus -compareStatus :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Comparereport.CompareStatus -compareStatus cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermInject v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "byteEq", (\input -> Eithers.map (\t -> Comparereport.CompareStatusByteEq) (ExtractCore.decodeUnit cx input))), - (Core.Name "differ", (\input -> Eithers.map (\t -> Comparereport.CompareStatusDiffer) (ExtractCore.decodeUnit cx input))), - ( - Core.Name "missing", - (\input -> Eithers.map (\t -> Comparereport.CompareStatusMissing) (ExtractCore.decodeUnit cx input)))] - in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm)) - _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.comparereport.ModuleCompare -moduleCompare :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Comparereport.ModuleCompare -moduleCompare cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "module" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_module -> Eithers.bind (ExtractCore.requireField "status" compareStatus fieldMap cx) (\field_status -> Eithers.bind (ExtractCore.requireField "ourSize" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_ourSize -> Eithers.bind (ExtractCore.requireField "canonSize" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_canonSize -> Eithers.bind (ExtractCore.requireField "diffLines" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_diffLines -> Right (Comparereport.ModuleCompare { - Comparereport.moduleCompareModule = field_module, - Comparereport.moduleCompareStatus = field_status, - Comparereport.moduleCompareOurSize = field_ourSize, - Comparereport.moduleCompareCanonSize = field_canonSize, - Comparereport.moduleCompareDiffLines = field_diffLines}))))))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.comparereport.ModuleCompare")) (ExtractCore.stripWithDecodingError cx raw) diff --git a/src/main/haskell/Hydra/Decode/Build/Format.hs b/src/main/haskell/Hydra/Decode/Build/Format.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Decode/Build/Format.hs +++ /dev/null @@ -1,440 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.build.format - -module Hydra.Decode.Build.Format where - -import qualified Hydra.Build.Format as Format -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Packaging as Packaging -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Core as ExtractCore -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -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 -import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Util as Util -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Decoder for hydra.build.format.DefinitionNameConventionProfile -definitionNameConventionProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.DefinitionNameConventionProfile -definitionNameConventionProfile cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "severity" severity fieldMap cx) (\field_severity -> Eithers.bind (ExtractCore.requireField "allowUnderscores" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralBoolean v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected boolean literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_allowUnderscores -> Right (Format.DefinitionNameConventionProfile { - Format.definitionNameConventionProfileSeverity = field_severity, - Format.definitionNameConventionProfileAllowUnderscores = field_allowUnderscores})))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.DefinitionNameConventionProfile")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.DefinitionValidationProfile -definitionValidationProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.DefinitionValidationProfile -definitionValidationProfile cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "hasDescription" (ExtractCore.decodeMaybe documentationProfile) fieldMap cx) (\field_hasDescription -> Eithers.bind (ExtractCore.requireField "ordering" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_ordering -> Eithers.bind (ExtractCore.requireField "nameConvention" (ExtractCore.decodeMaybe definitionNameConventionProfile) fieldMap cx) (\field_nameConvention -> Eithers.bind (ExtractCore.requireField "notInModuleName" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_notInModuleName -> Eithers.bind (ExtractCore.requireField "duplicateName" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_duplicateName -> Right (Format.DefinitionValidationProfile { - Format.definitionValidationProfileHasDescription = field_hasDescription, - Format.definitionValidationProfileOrdering = field_ordering, - Format.definitionValidationProfileNameConvention = field_nameConvention, - Format.definitionValidationProfileNotInModuleName = field_notInModuleName, - Format.definitionValidationProfileDuplicateName = field_duplicateName}))))))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.DefinitionValidationProfile")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.DigestEntry -digestEntry :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.DigestEntry -digestEntry cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "kind" digestKind fieldMap cx) (\field_kind -> Eithers.bind (ExtractCore.requireField "hash" sha256Hash fieldMap cx) (\field_hash -> Right (Format.DigestEntry { - Format.digestEntryKind = field_kind, - Format.digestEntryHash = field_hash})))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.DigestEntry")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.DigestKind -digestKind :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.DigestKind -digestKind cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermInject v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "dslSource", (\input -> Eithers.map (\t -> Format.DigestKindDslSource) (ExtractCore.decodeUnit cx input))), - (Core.Name "jsonFile", (\input -> Eithers.map (\t -> Format.DigestKindJsonFile) (ExtractCore.decodeUnit cx input))), - (Core.Name "targetFile", (\input -> Eithers.map (\t -> Format.DigestKindTargetFile) (ExtractCore.decodeUnit cx input))), - (Core.Name "runtimeFile", (\input -> Eithers.map (\t -> Format.DigestKindRuntimeFile) (ExtractCore.decodeUnit cx input))), - (Core.Name "other", (\input -> Eithers.map (\t -> Format.DigestKindOther) (ExtractCore.decodeUnit cx input)))] - in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm)) - _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.DocumentationProfile -documentationProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.DocumentationProfile -documentationProfile cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "severity" severity fieldMap cx) (\field_severity -> Eithers.bind (ExtractCore.requireField "exemptDeprecated" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralBoolean v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected boolean literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_exemptDeprecated -> Right (Format.DocumentationProfile { - Format.documentationProfileSeverity = field_severity, - Format.documentationProfileExemptDeprecated = field_exemptDeprecated})))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.DocumentationProfile")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.Generation -generation :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.Generation -generation cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "generatorId" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_generatorId -> Eithers.bind (ExtractCore.requireField "mode" generationMode fieldMap cx) (\field_mode -> Eithers.bind (ExtractCore.requireField "host" languageName fieldMap cx) (\field_host -> Eithers.bind (ExtractCore.requireField "hydraVersion" (ExtractCore.decodeMaybe Packaging.version) fieldMap cx) (\field_hydraVersion -> Eithers.bind (ExtractCore.requireField "revision" (ExtractCore.decodeMaybe (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_revision -> Eithers.bind (ExtractCore.requireField "timestamp" (ExtractCore.decodeMaybe (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_timestamp -> Right (Format.Generation { - Format.generationGeneratorId = field_generatorId, - Format.generationMode = field_mode, - Format.generationHost = field_host, - Format.generationHydraVersion = field_hydraVersion, - Format.generationRevision = field_revision, - Format.generationTimestamp = field_timestamp})))))))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.Generation")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.GenerationMode -generationMode :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.GenerationMode -generationMode cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermInject v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "published", (\input -> Eithers.map (\t -> Format.GenerationModePublished) (ExtractCore.decodeUnit cx input))), - (Core.Name "shim", (\input -> Eithers.map (\t -> Format.GenerationModeShim) (ExtractCore.decodeUnit cx input)))] - in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm)) - _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.HostOverride -hostOverride :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.HostOverride -hostOverride cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermInject v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "local", (\input -> Eithers.map (\t -> Format.HostOverrideLocal) (ExtractCore.decodeUnit cx input))), - (Core.Name "version", (\input -> Eithers.map (\t -> Format.HostOverrideVersion t) (Packaging.version cx input)))] - in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm)) - _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.InputDigest -inputDigest :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.InputDigest -inputDigest cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "digestFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_digestFormatVersion -> Eithers.bind (ExtractCore.requireField "moduleFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_moduleFormatVersion -> Eithers.bind (ExtractCore.requireField "selfHash" (ExtractCore.decodeMaybe sha256Hash) fieldMap cx) (\field_selfHash -> Eithers.bind (ExtractCore.requireField "dependencyHashes" (ExtractCore.decodeMap Packaging.packageName sha256Hash) fieldMap cx) (\field_dependencyHashes -> Eithers.bind (ExtractCore.requireField "moduleHashes" (ExtractCore.decodeMap Packaging.moduleName sha256Hash) fieldMap cx) (\field_moduleHashes -> Right (Format.InputDigest { - Format.inputDigestDigestFormatVersion = field_digestFormatVersion, - Format.inputDigestModuleFormatVersion = field_moduleFormatVersion, - Format.inputDigestSelfHash = field_selfHash, - Format.inputDigestDependencyHashes = field_dependencyHashes, - Format.inputDigestModuleHashes = field_moduleHashes}))))))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.InputDigest")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.LanguageName -languageName :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.LanguageName -languageName cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Format.LanguageName b) ((\raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx raw2)) (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.LanguageProfile -languageProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.LanguageProfile -languageProfile cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "name" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "coderPackage" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_coderPackage -> Eithers.bind (ExtractCore.requireField "family" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_family -> Right (Format.LanguageProfile { - Format.languageProfileName = field_name, - Format.languageProfileCoderPackage = field_coderPackage, - Format.languageProfileFamily = field_family}))))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.LanguageProfile")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.ModuleValidationProfile -moduleValidationProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.ModuleValidationProfile -moduleValidationProfile cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "definitions" (ExtractCore.decodeMaybe definitionValidationProfile) fieldMap cx) (\field_definitions -> Eithers.bind (ExtractCore.requireField "nameConvention" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_nameConvention -> Eithers.bind (ExtractCore.requireField "conflictingVariantName" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_conflictingVariantName -> Right (Format.ModuleValidationProfile { - Format.moduleValidationProfileDefinitions = field_definitions, - Format.moduleValidationProfileNameConvention = field_nameConvention, - Format.moduleValidationProfileConflictingVariantName = field_conflictingVariantName}))))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.ModuleValidationProfile")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.OutputDigest -outputDigest :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.OutputDigest -outputDigest cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "digestFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_digestFormatVersion -> Eithers.bind (ExtractCore.requireField "moduleFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_moduleFormatVersion -> Eithers.bind (ExtractCore.requireField "generator" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_generator -> Eithers.bind (ExtractCore.requireField "generation" generation fieldMap cx) (\field_generation -> Eithers.bind (ExtractCore.requireField "selfHash" (ExtractCore.decodeMaybe sha256Hash) fieldMap cx) (\field_selfHash -> Eithers.bind (ExtractCore.requireField "dependencyHashes" (ExtractCore.decodeMap Packaging.packageName sha256Hash) fieldMap cx) (\field_dependencyHashes -> Eithers.bind (ExtractCore.requireField "inputs" (ExtractCore.decodeMap (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) digestEntry) fieldMap cx) (\field_inputs -> Eithers.bind (ExtractCore.requireField "outputs" (ExtractCore.decodeMap (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) digestEntry) fieldMap cx) (\field_outputs -> Right (Format.OutputDigest { - Format.outputDigestDigestFormatVersion = field_digestFormatVersion, - Format.outputDigestModuleFormatVersion = field_moduleFormatVersion, - Format.outputDigestGenerator = field_generator, - Format.outputDigestGeneration = field_generation, - Format.outputDigestSelfHash = field_selfHash, - Format.outputDigestDependencyHashes = field_dependencyHashes, - Format.outputDigestInputs = field_inputs, - Format.outputDigestOutputs = field_outputs})))))))))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.OutputDigest")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.PackageDescriptor -packageDescriptor :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.PackageDescriptor -packageDescriptor cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "packageFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_packageFormatVersion -> Eithers.bind (ExtractCore.requireField "name" Packaging.packageName fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "description" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_description -> Eithers.bind (ExtractCore.requireField "sourceLanguage" languageName fieldMap cx) (\field_sourceLanguage -> Eithers.bind (ExtractCore.requireField "targetLanguages" (ExtractCore.decodeMaybe (ExtractCore.decodeList languageName)) fieldMap cx) (\field_targetLanguages -> Eithers.bind (ExtractCore.requireField "dependencies" (ExtractCore.decodeList Packaging.packageName) fieldMap cx) (\field_dependencies -> Eithers.bind (ExtractCore.requireField "validation" (ExtractCore.decodeMaybe packageValidationConfiguration) fieldMap cx) (\field_validation -> Right (Format.PackageDescriptor { - Format.packageDescriptorPackageFormatVersion = field_packageFormatVersion, - Format.packageDescriptorName = field_name, - Format.packageDescriptorDescription = field_description, - Format.packageDescriptorSourceLanguage = field_sourceLanguage, - Format.packageDescriptorTargetLanguages = field_targetLanguages, - Format.packageDescriptorDependencies = field_dependencies, - Format.packageDescriptorValidation = field_validation}))))))))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.PackageDescriptor")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.PackageManifest -packageManifest :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.PackageManifest -packageManifest cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "manifestFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_manifestFormatVersion -> Eithers.bind (ExtractCore.requireField "moduleFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_moduleFormatVersion -> Eithers.bind (ExtractCore.requireField "package" Packaging.packageName fieldMap cx) (\field_package -> Eithers.bind (ExtractCore.requireField "mainModules" (ExtractCore.decodeList Packaging.moduleName) fieldMap cx) (\field_mainModules -> Eithers.bind (ExtractCore.requireField "testModules" (ExtractCore.decodeList Packaging.moduleName) fieldMap cx) (\field_testModules -> Eithers.bind (ExtractCore.requireField "mainDslModules" (ExtractCore.decodeList Packaging.moduleName) fieldMap cx) (\field_mainDslModules -> Eithers.bind (ExtractCore.requireField "mainEncodingModules" (ExtractCore.decodeList Packaging.moduleName) fieldMap cx) (\field_mainEncodingModules -> Right (Format.PackageManifest { - Format.packageManifestManifestFormatVersion = field_manifestFormatVersion, - Format.packageManifestModuleFormatVersion = field_moduleFormatVersion, - Format.packageManifestPackage = field_package, - Format.packageManifestMainModules = field_mainModules, - Format.packageManifestTestModules = field_testModules, - Format.packageManifestMainDslModules = field_mainDslModules, - Format.packageManifestMainEncodingModules = field_mainEncodingModules}))))))))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.PackageManifest")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.PackageValidationConfiguration -packageValidationConfiguration :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.PackageValidationConfiguration -packageValidationConfiguration cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "package" (ExtractCore.decodeMaybe packageValidationProfile) fieldMap cx) (\field_package -> Eithers.bind (ExtractCore.requireField "module" (ExtractCore.decodeMaybe moduleValidationProfile) fieldMap cx) (\field_module -> Eithers.bind (ExtractCore.requireField "type" (ExtractCore.decodeMaybe typeValidationProfile) fieldMap cx) (\field_type -> Eithers.bind (ExtractCore.requireField "term" (ExtractCore.decodeMaybe termValidationProfile) fieldMap cx) (\field_term -> Right (Format.PackageValidationConfiguration { - Format.packageValidationConfigurationPackage = field_package, - Format.packageValidationConfigurationModule = field_module, - Format.packageValidationConfigurationType = field_type, - Format.packageValidationConfigurationTerm = field_term})))))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.PackageValidationConfiguration")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.PackageValidationProfile -packageValidationProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.PackageValidationProfile -packageValidationProfile cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "conflictingModuleName" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_conflictingModuleName -> Eithers.bind (ExtractCore.requireField "duplicateModuleName" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_duplicateModuleName -> Eithers.bind (ExtractCore.requireField "nameConvention" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_nameConvention -> Right (Format.PackageValidationProfile { - Format.packageValidationProfileConflictingModuleName = field_conflictingModuleName, - Format.packageValidationProfileDuplicateModuleName = field_duplicateModuleName, - Format.packageValidationProfileNameConvention = field_nameConvention}))))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.PackageValidationProfile")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.RepositoryDescriptor -repositoryDescriptor :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.RepositoryDescriptor -repositoryDescriptor cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "currentVersion" Packaging.version fieldMap cx) (\field_currentVersion -> Eithers.bind (ExtractCore.requireField "hostVersion" Packaging.version fieldMap cx) (\field_hostVersion -> Eithers.bind (ExtractCore.requireField "hostOverrides" (ExtractCore.decodeMap languageName hostOverride) fieldMap cx) (\field_hostOverrides -> Eithers.bind (ExtractCore.requireField "group" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_group -> Eithers.bind (ExtractCore.requireField "author" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_author -> Eithers.bind (ExtractCore.requireField "url" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_url -> Eithers.bind (ExtractCore.requireField "license" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_license -> Eithers.bind (ExtractCore.requireField "packages" (ExtractCore.decodeList Packaging.packageName) fieldMap cx) (\field_packages -> Right (Format.RepositoryDescriptor { - Format.repositoryDescriptorCurrentVersion = field_currentVersion, - Format.repositoryDescriptorHostVersion = field_hostVersion, - Format.repositoryDescriptorHostOverrides = field_hostOverrides, - Format.repositoryDescriptorGroup = field_group, - Format.repositoryDescriptorAuthor = field_author, - Format.repositoryDescriptorUrl = field_url, - Format.repositoryDescriptorLicense = field_license, - Format.repositoryDescriptorPackages = field_packages})))))))))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.RepositoryDescriptor")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.Severity -severity :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.Severity -severity cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermInject v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "error", (\input -> Eithers.map (\t -> Format.SeverityError) (ExtractCore.decodeUnit cx input))), - (Core.Name "warning", (\input -> Eithers.map (\t -> Format.SeverityWarning) (ExtractCore.decodeUnit cx input)))] - in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm)) - _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.Sha256Hash -sha256Hash :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.Sha256Hash -sha256Hash cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Format.Sha256Hash b) ((\raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx raw2)) (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.TermValidationProfile -termValidationProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.TermValidationProfile -termValidationProfile cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "duplicateBinding" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_duplicateBinding -> Eithers.bind (ExtractCore.requireField "emptyTermAnnotation" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_emptyTermAnnotation -> Eithers.bind (ExtractCore.requireField "undefinedVariable" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_undefinedVariable -> Right (Format.TermValidationProfile { - Format.termValidationProfileDuplicateBinding = field_duplicateBinding, - Format.termValidationProfileEmptyTermAnnotation = field_emptyTermAnnotation, - Format.termValidationProfileUndefinedVariable = field_undefinedVariable}))))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.TermValidationProfile")) (ExtractCore.stripWithDecodingError cx raw) - --- | Decoder for hydra.build.format.TypeValidationProfile -typeValidationProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.TypeValidationProfile -typeValidationProfile cx raw = - Eithers.either (\err -> Left err) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = ExtractCore.toFieldMap v0 - in (Eithers.bind (ExtractCore.requireField "emptyAnnotation" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_emptyAnnotation -> Eithers.bind (ExtractCore.requireField "duplicateField" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_duplicateField -> Eithers.bind (ExtractCore.requireField "singleVariantUnion" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_singleVariantUnion -> Right (Format.TypeValidationProfile { - Format.typeValidationProfileEmptyAnnotation = field_emptyAnnotation, - Format.typeValidationProfileDuplicateField = field_duplicateField, - Format.typeValidationProfileSingleVariantUnion = field_singleVariantUnion}))))) - _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.TypeValidationProfile")) (ExtractCore.stripWithDecodingError cx raw) diff --git a/src/main/haskell/Hydra/Dsl/Build/Assembly.hs b/src/main/haskell/Hydra/Dsl/Build/Assembly.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Dsl/Build/Assembly.hs +++ /dev/null @@ -1,375 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.build.assembly - -module Hydra.Dsl.Build.Assembly where - -import qualified Hydra.Build.Assembly as Assembly -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Build.Assembly as DecodeBuildAssembly -import qualified Hydra.Encode.Build.Assembly as EncodeBuildAssembly -import qualified Hydra.Typed as Typed -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | DSL constructor for hydra.build.assembly.AssemblyEntry -assemblyEntry :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Assembly.AssemblyEntryKind -> Typed.TypedTerm [String] -> Typed.TypedTerm Assembly.AssemblyEntry -assemblyEntry sourceTree destTree kind exclude = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "sourceTree"), - Core.fieldTerm = (Typed.unTypedTerm sourceTree)}, - Core.Field { - Core.fieldName = (Core.Name "destTree"), - Core.fieldTerm = (Typed.unTypedTerm destTree)}, - Core.Field { - Core.fieldName = (Core.Name "kind"), - Core.fieldTerm = (Typed.unTypedTerm kind)}, - Core.Field { - Core.fieldName = (Core.Name "exclude"), - Core.fieldTerm = (Typed.unTypedTerm exclude)}]})) - --- | DSL name token for hydra.build.assembly.AssemblyEntry -assemblyEntryAssemblyEntry :: Typed.TypedName Assembly.AssemblyEntry -assemblyEntryAssemblyEntry = Typed.TypedName (Core.Name "hydra.build.assembly.AssemblyEntry") - --- | DSL accessor for the destTree field of hydra.build.assembly.AssemblyEntry -assemblyEntryDestTree :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm String -assemblyEntryDestTree x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.projectionFieldName = (Core.Name "destTree")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the exclude field of hydra.build.assembly.AssemblyEntry -assemblyEntryExclude :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm [String] -assemblyEntryExclude x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.projectionFieldName = (Core.Name "exclude")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the kind field of hydra.build.assembly.AssemblyEntry -assemblyEntryKind :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm Assembly.AssemblyEntryKind -assemblyEntryKind x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.projectionFieldName = (Core.Name "kind")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL name token for hydra.build.assembly.AssemblyEntryKind -assemblyEntryKindAssemblyEntryKind :: Typed.TypedName Assembly.AssemblyEntryKind -assemblyEntryKindAssemblyEntryKind = Typed.TypedName (Core.Name "hydra.build.assembly.AssemblyEntryKind") - --- | DSL injection for the merge variant of hydra.build.assembly.AssemblyEntryKind -assemblyEntryKindMerge :: Typed.TypedTerm Assembly.AssemblyEntryKind -assemblyEntryKindMerge = - Typed.TypedTerm (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntryKind"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "merge"), - Core.fieldTerm = Core.TermUnit}})) - --- | DSL injection for the symlinkDir variant of hydra.build.assembly.AssemblyEntryKind -assemblyEntryKindSymlinkDir :: Typed.TypedTerm Assembly.AssemblyEntryKind -assemblyEntryKindSymlinkDir = - Typed.TypedTerm (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntryKind"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "symlinkDir"), - Core.fieldTerm = Core.TermUnit}})) - --- | DSL injection for the symlinkTree variant of hydra.build.assembly.AssemblyEntryKind -assemblyEntryKindSymlinkTree :: Typed.TypedTerm Assembly.AssemblyEntryKind -assemblyEntryKindSymlinkTree = - Typed.TypedTerm (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntryKind"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "symlinkTree"), - Core.fieldTerm = Core.TermUnit}})) - --- | DSL injection for the wipeThenCopy variant of hydra.build.assembly.AssemblyEntryKind -assemblyEntryKindWipeThenCopy :: Typed.TypedTerm Assembly.AssemblyEntryKind -assemblyEntryKindWipeThenCopy = - Typed.TypedTerm (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntryKind"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wipeThenCopy"), - Core.fieldTerm = Core.TermUnit}})) - --- | DSL accessor for the sourceTree field of hydra.build.assembly.AssemblyEntry -assemblyEntrySourceTree :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm String -assemblyEntrySourceTree x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.projectionFieldName = (Core.Name "sourceTree")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the destTree field of hydra.build.assembly.AssemblyEntry -assemblyEntryWithDestTree :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm String -> Typed.TypedTerm Assembly.AssemblyEntry -assemblyEntryWithDestTree original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "sourceTree"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.projectionFieldName = (Core.Name "sourceTree")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "destTree"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "kind"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.projectionFieldName = (Core.Name "kind")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "exclude"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.projectionFieldName = (Core.Name "exclude")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the exclude field of hydra.build.assembly.AssemblyEntry -assemblyEntryWithExclude :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm [String] -> Typed.TypedTerm Assembly.AssemblyEntry -assemblyEntryWithExclude original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "sourceTree"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.projectionFieldName = (Core.Name "sourceTree")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "destTree"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.projectionFieldName = (Core.Name "destTree")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "kind"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.projectionFieldName = (Core.Name "kind")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "exclude"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL updater for the kind field of hydra.build.assembly.AssemblyEntry -assemblyEntryWithKind :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm Assembly.AssemblyEntryKind -> Typed.TypedTerm Assembly.AssemblyEntry -assemblyEntryWithKind original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "sourceTree"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.projectionFieldName = (Core.Name "sourceTree")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "destTree"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.projectionFieldName = (Core.Name "destTree")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "kind"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "exclude"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.projectionFieldName = (Core.Name "exclude")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the sourceTree field of hydra.build.assembly.AssemblyEntry -assemblyEntryWithSourceTree :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm String -> Typed.TypedTerm Assembly.AssemblyEntry -assemblyEntryWithSourceTree original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "sourceTree"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "destTree"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.projectionFieldName = (Core.Name "destTree")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "kind"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.projectionFieldName = (Core.Name "kind")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "exclude"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.projectionFieldName = (Core.Name "exclude")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL constructor for hydra.build.assembly.AssemblyPlan -assemblyPlan :: Typed.TypedTerm [Assembly.AssemblyEntry] -> Typed.TypedTerm [Assembly.KeepPathEntry] -> Typed.TypedTerm Assembly.AssemblyPlan -assemblyPlan entries keepPaths = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.assembly.AssemblyPlan"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "entries"), - Core.fieldTerm = (Typed.unTypedTerm entries)}, - Core.Field { - Core.fieldName = (Core.Name "keepPaths"), - Core.fieldTerm = (Typed.unTypedTerm keepPaths)}]})) - --- | DSL name token for hydra.build.assembly.AssemblyPlan -assemblyPlanAssemblyPlan :: Typed.TypedName Assembly.AssemblyPlan -assemblyPlanAssemblyPlan = Typed.TypedName (Core.Name "hydra.build.assembly.AssemblyPlan") - --- | DSL accessor for the entries field of hydra.build.assembly.AssemblyPlan -assemblyPlanEntries :: Typed.TypedTerm Assembly.AssemblyPlan -> Typed.TypedTerm [Assembly.AssemblyEntry] -assemblyPlanEntries x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyPlan"), - Core.projectionFieldName = (Core.Name "entries")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the keepPaths field of hydra.build.assembly.AssemblyPlan -assemblyPlanKeepPaths :: Typed.TypedTerm Assembly.AssemblyPlan -> Typed.TypedTerm [Assembly.KeepPathEntry] -assemblyPlanKeepPaths x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyPlan"), - Core.projectionFieldName = (Core.Name "keepPaths")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the entries field of hydra.build.assembly.AssemblyPlan -assemblyPlanWithEntries :: Typed.TypedTerm Assembly.AssemblyPlan -> Typed.TypedTerm [Assembly.AssemblyEntry] -> Typed.TypedTerm Assembly.AssemblyPlan -assemblyPlanWithEntries original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.assembly.AssemblyPlan"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "entries"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "keepPaths"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyPlan"), - Core.projectionFieldName = (Core.Name "keepPaths")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the keepPaths field of hydra.build.assembly.AssemblyPlan -assemblyPlanWithKeepPaths :: Typed.TypedTerm Assembly.AssemblyPlan -> Typed.TypedTerm [Assembly.KeepPathEntry] -> Typed.TypedTerm Assembly.AssemblyPlan -assemblyPlanWithKeepPaths original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.assembly.AssemblyPlan"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "entries"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.AssemblyPlan"), - Core.projectionFieldName = (Core.Name "entries")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "keepPaths"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL constructor for hydra.build.assembly.KeepPathEntry -keepPathEntry :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Assembly.KeepPathEntry -keepPathEntry sourceSetDir relPath = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.assembly.KeepPathEntry"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "sourceSetDir"), - Core.fieldTerm = (Typed.unTypedTerm sourceSetDir)}, - Core.Field { - Core.fieldName = (Core.Name "relPath"), - Core.fieldTerm = (Typed.unTypedTerm relPath)}]})) - --- | DSL name token for hydra.build.assembly.KeepPathEntry -keepPathEntryKeepPathEntry :: Typed.TypedName Assembly.KeepPathEntry -keepPathEntryKeepPathEntry = Typed.TypedName (Core.Name "hydra.build.assembly.KeepPathEntry") - --- | DSL accessor for the relPath field of hydra.build.assembly.KeepPathEntry -keepPathEntryRelPath :: Typed.TypedTerm Assembly.KeepPathEntry -> Typed.TypedTerm String -keepPathEntryRelPath x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.KeepPathEntry"), - Core.projectionFieldName = (Core.Name "relPath")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the sourceSetDir field of hydra.build.assembly.KeepPathEntry -keepPathEntrySourceSetDir :: Typed.TypedTerm Assembly.KeepPathEntry -> Typed.TypedTerm String -keepPathEntrySourceSetDir x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.KeepPathEntry"), - Core.projectionFieldName = (Core.Name "sourceSetDir")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the relPath field of hydra.build.assembly.KeepPathEntry -keepPathEntryWithRelPath :: Typed.TypedTerm Assembly.KeepPathEntry -> Typed.TypedTerm String -> Typed.TypedTerm Assembly.KeepPathEntry -keepPathEntryWithRelPath original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.assembly.KeepPathEntry"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "sourceSetDir"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.KeepPathEntry"), - Core.projectionFieldName = (Core.Name "sourceSetDir")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "relPath"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL updater for the sourceSetDir field of hydra.build.assembly.KeepPathEntry -keepPathEntryWithSourceSetDir :: Typed.TypedTerm Assembly.KeepPathEntry -> Typed.TypedTerm String -> Typed.TypedTerm Assembly.KeepPathEntry -keepPathEntryWithSourceSetDir original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.assembly.KeepPathEntry"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "sourceSetDir"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "relPath"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.assembly.KeepPathEntry"), - Core.projectionFieldName = (Core.Name "relPath")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) diff --git a/src/main/haskell/Hydra/Dsl/Build/Benchresult.hs b/src/main/haskell/Hydra/Dsl/Build/Benchresult.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Dsl/Build/Benchresult.hs +++ /dev/null @@ -1,597 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.build.benchresult - -module Hydra.Dsl.Build.Benchresult where - -import qualified Hydra.Build.Benchresult as Benchresult -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Build.Benchresult as DecodeBuildBenchresult -import qualified Hydra.Encode.Build.Benchresult as EncodeBuildBenchresult -import qualified Hydra.Typed as Typed -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Map as M - --- | DSL constructor for hydra.build.benchresult.BenchMetadata -benchMetadata :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.BenchMetadata -benchMetadata timestamp language branch commit commitMessage = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "timestamp"), - Core.fieldTerm = (Typed.unTypedTerm timestamp)}, - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Typed.unTypedTerm language)}, - Core.Field { - Core.fieldName = (Core.Name "branch"), - Core.fieldTerm = (Typed.unTypedTerm branch)}, - Core.Field { - Core.fieldName = (Core.Name "commit"), - Core.fieldTerm = (Typed.unTypedTerm commit)}, - Core.Field { - Core.fieldName = (Core.Name "commitMessage"), - Core.fieldTerm = (Typed.unTypedTerm commitMessage)}]})) - --- | DSL name token for hydra.build.benchresult.BenchMetadata -benchMetadataBenchMetadata :: Typed.TypedName Benchresult.BenchMetadata -benchMetadataBenchMetadata = Typed.TypedName (Core.Name "hydra.build.benchresult.BenchMetadata") - --- | DSL accessor for the branch field of hydra.build.benchresult.BenchMetadata -benchMetadataBranch :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -benchMetadataBranch x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "branch")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the commit field of hydra.build.benchresult.BenchMetadata -benchMetadataCommit :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -benchMetadataCommit x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "commit")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the commitMessage field of hydra.build.benchresult.BenchMetadata -benchMetadataCommitMessage :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -benchMetadataCommitMessage x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "commitMessage")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the language field of hydra.build.benchresult.BenchMetadata -benchMetadataLanguage :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -benchMetadataLanguage x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "language")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the timestamp field of hydra.build.benchresult.BenchMetadata -benchMetadataTimestamp :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -benchMetadataTimestamp x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "timestamp")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the branch field of hydra.build.benchresult.BenchMetadata -benchMetadataWithBranch :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.BenchMetadata -benchMetadataWithBranch original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "timestamp"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "timestamp")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "language")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "branch"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "commit"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "commit")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "commitMessage"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "commitMessage")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the commit field of hydra.build.benchresult.BenchMetadata -benchMetadataWithCommit :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.BenchMetadata -benchMetadataWithCommit original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "timestamp"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "timestamp")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "language")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "branch"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "branch")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "commit"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "commitMessage"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "commitMessage")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the commitMessage field of hydra.build.benchresult.BenchMetadata -benchMetadataWithCommitMessage :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.BenchMetadata -benchMetadataWithCommitMessage original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "timestamp"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "timestamp")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "language")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "branch"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "branch")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "commit"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "commit")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "commitMessage"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL updater for the language field of hydra.build.benchresult.BenchMetadata -benchMetadataWithLanguage :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.BenchMetadata -benchMetadataWithLanguage original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "timestamp"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "timestamp")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "branch"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "branch")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "commit"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "commit")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "commitMessage"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "commitMessage")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the timestamp field of hydra.build.benchresult.BenchMetadata -benchMetadataWithTimestamp :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.BenchMetadata -benchMetadataWithTimestamp original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "timestamp"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "language")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "branch"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "branch")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "commit"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "commit")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "commitMessage"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.projectionFieldName = (Core.Name "commitMessage")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL constructor for hydra.build.benchresult.GenBenchResult -genBenchResult :: Typed.TypedTerm String -> Typed.TypedTerm Int -> Typed.TypedTerm (M.Map String Benchresult.HostResult) -> Typed.TypedTerm (Maybe Benchresult.BenchMetadata) -> Typed.TypedTerm Benchresult.GenBenchResult -genBenchResult target runs hosts metadata = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Typed.unTypedTerm target)}, - Core.Field { - Core.fieldName = (Core.Name "runs"), - Core.fieldTerm = (Typed.unTypedTerm runs)}, - Core.Field { - Core.fieldName = (Core.Name "hosts"), - Core.fieldTerm = (Typed.unTypedTerm hosts)}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = (Typed.unTypedTerm metadata)}]})) - --- | DSL name token for hydra.build.benchresult.GenBenchResult -genBenchResultGenBenchResult :: Typed.TypedName Benchresult.GenBenchResult -genBenchResultGenBenchResult = Typed.TypedName (Core.Name "hydra.build.benchresult.GenBenchResult") - --- | DSL accessor for the hosts field of hydra.build.benchresult.GenBenchResult -genBenchResultHosts :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm (M.Map String Benchresult.HostResult) -genBenchResultHosts x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.projectionFieldName = (Core.Name "hosts")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the metadata field of hydra.build.benchresult.GenBenchResult -genBenchResultMetadata :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm (Maybe Benchresult.BenchMetadata) -genBenchResultMetadata x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.projectionFieldName = (Core.Name "metadata")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the runs field of hydra.build.benchresult.GenBenchResult -genBenchResultRuns :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm Int -genBenchResultRuns x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.projectionFieldName = (Core.Name "runs")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the target field of hydra.build.benchresult.GenBenchResult -genBenchResultTarget :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm String -genBenchResultTarget x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.projectionFieldName = (Core.Name "target")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the hosts field of hydra.build.benchresult.GenBenchResult -genBenchResultWithHosts :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm (M.Map String Benchresult.HostResult) -> Typed.TypedTerm Benchresult.GenBenchResult -genBenchResultWithHosts original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.projectionFieldName = (Core.Name "target")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "runs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.projectionFieldName = (Core.Name "runs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hosts"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.projectionFieldName = (Core.Name "metadata")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the metadata field of hydra.build.benchresult.GenBenchResult -genBenchResultWithMetadata :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm (Maybe Benchresult.BenchMetadata) -> Typed.TypedTerm Benchresult.GenBenchResult -genBenchResultWithMetadata original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.projectionFieldName = (Core.Name "target")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "runs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.projectionFieldName = (Core.Name "runs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hosts"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.projectionFieldName = (Core.Name "hosts")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL updater for the runs field of hydra.build.benchresult.GenBenchResult -genBenchResultWithRuns :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm Int -> Typed.TypedTerm Benchresult.GenBenchResult -genBenchResultWithRuns original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.projectionFieldName = (Core.Name "target")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "runs"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "hosts"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.projectionFieldName = (Core.Name "hosts")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.projectionFieldName = (Core.Name "metadata")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the target field of hydra.build.benchresult.GenBenchResult -genBenchResultWithTarget :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.GenBenchResult -genBenchResultWithTarget original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "runs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.projectionFieldName = (Core.Name "runs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hosts"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.projectionFieldName = (Core.Name "hosts")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.projectionFieldName = (Core.Name "metadata")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL constructor for hydra.build.benchresult.HostResult -hostResult :: Typed.TypedTerm Int -> Typed.TypedTerm (M.Map String Benchresult.RunStats) -> Typed.TypedTerm Benchresult.HostResult -hostResult setupMs packages = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.HostResult"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "setupMs"), - Core.fieldTerm = (Typed.unTypedTerm setupMs)}, - Core.Field { - Core.fieldName = (Core.Name "packages"), - Core.fieldTerm = (Typed.unTypedTerm packages)}]})) - --- | DSL name token for hydra.build.benchresult.HostResult -hostResultHostResult :: Typed.TypedName Benchresult.HostResult -hostResultHostResult = Typed.TypedName (Core.Name "hydra.build.benchresult.HostResult") - --- | DSL accessor for the packages field of hydra.build.benchresult.HostResult -hostResultPackages :: Typed.TypedTerm Benchresult.HostResult -> Typed.TypedTerm (M.Map String Benchresult.RunStats) -hostResultPackages x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.HostResult"), - Core.projectionFieldName = (Core.Name "packages")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the setupMs field of hydra.build.benchresult.HostResult -hostResultSetupMs :: Typed.TypedTerm Benchresult.HostResult -> Typed.TypedTerm Int -hostResultSetupMs x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.HostResult"), - Core.projectionFieldName = (Core.Name "setupMs")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the packages field of hydra.build.benchresult.HostResult -hostResultWithPackages :: Typed.TypedTerm Benchresult.HostResult -> Typed.TypedTerm (M.Map String Benchresult.RunStats) -> Typed.TypedTerm Benchresult.HostResult -hostResultWithPackages original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.HostResult"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "setupMs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.HostResult"), - Core.projectionFieldName = (Core.Name "setupMs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "packages"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL updater for the setupMs field of hydra.build.benchresult.HostResult -hostResultWithSetupMs :: Typed.TypedTerm Benchresult.HostResult -> Typed.TypedTerm Int -> Typed.TypedTerm Benchresult.HostResult -hostResultWithSetupMs original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.HostResult"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "setupMs"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "packages"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.HostResult"), - Core.projectionFieldName = (Core.Name "packages")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL constructor for hydra.build.benchresult.RunStats -runStats :: Typed.TypedTerm [Int] -> Typed.TypedTerm Int -> Typed.TypedTerm Benchresult.RunStats -runStats runsMs medianMs = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.RunStats"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "runsMs"), - Core.fieldTerm = (Typed.unTypedTerm runsMs)}, - Core.Field { - Core.fieldName = (Core.Name "medianMs"), - Core.fieldTerm = (Typed.unTypedTerm medianMs)}]})) - --- | DSL accessor for the medianMs field of hydra.build.benchresult.RunStats -runStatsMedianMs :: Typed.TypedTerm Benchresult.RunStats -> Typed.TypedTerm Int -runStatsMedianMs x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.RunStats"), - Core.projectionFieldName = (Core.Name "medianMs")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL name token for hydra.build.benchresult.RunStats -runStatsRunStats :: Typed.TypedName Benchresult.RunStats -runStatsRunStats = Typed.TypedName (Core.Name "hydra.build.benchresult.RunStats") - --- | DSL accessor for the runsMs field of hydra.build.benchresult.RunStats -runStatsRunsMs :: Typed.TypedTerm Benchresult.RunStats -> Typed.TypedTerm [Int] -runStatsRunsMs x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.RunStats"), - Core.projectionFieldName = (Core.Name "runsMs")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the medianMs field of hydra.build.benchresult.RunStats -runStatsWithMedianMs :: Typed.TypedTerm Benchresult.RunStats -> Typed.TypedTerm Int -> Typed.TypedTerm Benchresult.RunStats -runStatsWithMedianMs original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.RunStats"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "runsMs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.RunStats"), - Core.projectionFieldName = (Core.Name "runsMs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "medianMs"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL updater for the runsMs field of hydra.build.benchresult.RunStats -runStatsWithRunsMs :: Typed.TypedTerm Benchresult.RunStats -> Typed.TypedTerm [Int] -> Typed.TypedTerm Benchresult.RunStats -runStatsWithRunsMs original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.RunStats"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "runsMs"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "medianMs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.benchresult.RunStats"), - Core.projectionFieldName = (Core.Name "medianMs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) diff --git a/src/main/haskell/Hydra/Dsl/Build/Comparereport.hs b/src/main/haskell/Hydra/Dsl/Build/Comparereport.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Dsl/Build/Comparereport.hs +++ /dev/null @@ -1,425 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.build.comparereport - -module Hydra.Dsl.Build.Comparereport where - -import qualified Hydra.Build.Comparereport as Comparereport -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Build.Comparereport as DecodeBuildComparereport -import qualified Hydra.Encode.Build.Comparereport as EncodeBuildComparereport -import qualified Hydra.Typed as Typed -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | DSL constructor for hydra.build.comparereport.CompareReport -compareReport :: Typed.TypedTerm [Comparereport.ModuleCompare] -> Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.CompareReport -compareReport rows byteEqCount total = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.comparereport.CompareReport"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "rows"), - Core.fieldTerm = (Typed.unTypedTerm rows)}, - Core.Field { - Core.fieldName = (Core.Name "byteEqCount"), - Core.fieldTerm = (Typed.unTypedTerm byteEqCount)}, - Core.Field { - Core.fieldName = (Core.Name "total"), - Core.fieldTerm = (Typed.unTypedTerm total)}]})) - --- | DSL accessor for the byteEqCount field of hydra.build.comparereport.CompareReport -compareReportByteEqCount :: Typed.TypedTerm Comparereport.CompareReport -> Typed.TypedTerm Int -compareReportByteEqCount x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.CompareReport"), - Core.projectionFieldName = (Core.Name "byteEqCount")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL name token for hydra.build.comparereport.CompareReport -compareReportCompareReport :: Typed.TypedName Comparereport.CompareReport -compareReportCompareReport = Typed.TypedName (Core.Name "hydra.build.comparereport.CompareReport") - --- | DSL accessor for the rows field of hydra.build.comparereport.CompareReport -compareReportRows :: Typed.TypedTerm Comparereport.CompareReport -> Typed.TypedTerm [Comparereport.ModuleCompare] -compareReportRows x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.CompareReport"), - Core.projectionFieldName = (Core.Name "rows")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the total field of hydra.build.comparereport.CompareReport -compareReportTotal :: Typed.TypedTerm Comparereport.CompareReport -> Typed.TypedTerm Int -compareReportTotal x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.CompareReport"), - Core.projectionFieldName = (Core.Name "total")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the byteEqCount field of hydra.build.comparereport.CompareReport -compareReportWithByteEqCount :: Typed.TypedTerm Comparereport.CompareReport -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.CompareReport -compareReportWithByteEqCount original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.comparereport.CompareReport"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "rows"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.CompareReport"), - Core.projectionFieldName = (Core.Name "rows")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "byteEqCount"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "total"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.CompareReport"), - Core.projectionFieldName = (Core.Name "total")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the rows field of hydra.build.comparereport.CompareReport -compareReportWithRows :: Typed.TypedTerm Comparereport.CompareReport -> Typed.TypedTerm [Comparereport.ModuleCompare] -> Typed.TypedTerm Comparereport.CompareReport -compareReportWithRows original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.comparereport.CompareReport"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "rows"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "byteEqCount"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.CompareReport"), - Core.projectionFieldName = (Core.Name "byteEqCount")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "total"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.CompareReport"), - Core.projectionFieldName = (Core.Name "total")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the total field of hydra.build.comparereport.CompareReport -compareReportWithTotal :: Typed.TypedTerm Comparereport.CompareReport -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.CompareReport -compareReportWithTotal original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.comparereport.CompareReport"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "rows"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.CompareReport"), - Core.projectionFieldName = (Core.Name "rows")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "byteEqCount"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.CompareReport"), - Core.projectionFieldName = (Core.Name "byteEqCount")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "total"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL injection for the byteEq variant of hydra.build.comparereport.CompareStatus -compareStatusByteEq :: Typed.TypedTerm Comparereport.CompareStatus -compareStatusByteEq = - Typed.TypedTerm (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.comparereport.CompareStatus"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "byteEq"), - Core.fieldTerm = Core.TermUnit}})) - --- | DSL name token for hydra.build.comparereport.CompareStatus -compareStatusCompareStatus :: Typed.TypedName Comparereport.CompareStatus -compareStatusCompareStatus = Typed.TypedName (Core.Name "hydra.build.comparereport.CompareStatus") - --- | DSL injection for the differ variant of hydra.build.comparereport.CompareStatus -compareStatusDiffer :: Typed.TypedTerm Comparereport.CompareStatus -compareStatusDiffer = - Typed.TypedTerm (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.comparereport.CompareStatus"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "differ"), - Core.fieldTerm = Core.TermUnit}})) - --- | DSL injection for the missing variant of hydra.build.comparereport.CompareStatus -compareStatusMissing :: Typed.TypedTerm Comparereport.CompareStatus -compareStatusMissing = - Typed.TypedTerm (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.comparereport.CompareStatus"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "missing"), - Core.fieldTerm = Core.TermUnit}})) - --- | DSL constructor for hydra.build.comparereport.ModuleCompare -moduleCompare :: Typed.TypedTerm String -> Typed.TypedTerm Comparereport.CompareStatus -> Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.ModuleCompare -moduleCompare module_ status ourSize canonSize diffLines = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = (Typed.unTypedTerm module_)}, - Core.Field { - Core.fieldName = (Core.Name "status"), - Core.fieldTerm = (Typed.unTypedTerm status)}, - Core.Field { - Core.fieldName = (Core.Name "ourSize"), - Core.fieldTerm = (Typed.unTypedTerm ourSize)}, - Core.Field { - Core.fieldName = (Core.Name "canonSize"), - Core.fieldTerm = (Typed.unTypedTerm canonSize)}, - Core.Field { - Core.fieldName = (Core.Name "diffLines"), - Core.fieldTerm = (Typed.unTypedTerm diffLines)}]})) - --- | DSL accessor for the canonSize field of hydra.build.comparereport.ModuleCompare -moduleCompareCanonSize :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Int -moduleCompareCanonSize x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "canonSize")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the diffLines field of hydra.build.comparereport.ModuleCompare -moduleCompareDiffLines :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Int -moduleCompareDiffLines x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "diffLines")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the module field of hydra.build.comparereport.ModuleCompare -moduleCompareModule :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm String -moduleCompareModule x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "module")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL name token for hydra.build.comparereport.ModuleCompare -moduleCompareModuleCompare :: Typed.TypedName Comparereport.ModuleCompare -moduleCompareModuleCompare = Typed.TypedName (Core.Name "hydra.build.comparereport.ModuleCompare") - --- | DSL accessor for the ourSize field of hydra.build.comparereport.ModuleCompare -moduleCompareOurSize :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Int -moduleCompareOurSize x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "ourSize")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the status field of hydra.build.comparereport.ModuleCompare -moduleCompareStatus :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Comparereport.CompareStatus -moduleCompareStatus x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "status")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the canonSize field of hydra.build.comparereport.ModuleCompare -moduleCompareWithCanonSize :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.ModuleCompare -moduleCompareWithCanonSize original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "module")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "status"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "status")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "ourSize"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "ourSize")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "canonSize"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "diffLines"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "diffLines")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the diffLines field of hydra.build.comparereport.ModuleCompare -moduleCompareWithDiffLines :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.ModuleCompare -moduleCompareWithDiffLines original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "module")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "status"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "status")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "ourSize"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "ourSize")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "canonSize"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "canonSize")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "diffLines"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL updater for the module field of hydra.build.comparereport.ModuleCompare -moduleCompareWithModule :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm String -> Typed.TypedTerm Comparereport.ModuleCompare -moduleCompareWithModule original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "status"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "status")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "ourSize"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "ourSize")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "canonSize"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "canonSize")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "diffLines"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "diffLines")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the ourSize field of hydra.build.comparereport.ModuleCompare -moduleCompareWithOurSize :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.ModuleCompare -moduleCompareWithOurSize original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "module")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "status"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "status")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "ourSize"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "canonSize"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "canonSize")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "diffLines"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "diffLines")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the status field of hydra.build.comparereport.ModuleCompare -moduleCompareWithStatus :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Comparereport.CompareStatus -> Typed.TypedTerm Comparereport.ModuleCompare -moduleCompareWithStatus original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "module")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "status"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "ourSize"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "ourSize")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "canonSize"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "canonSize")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "diffLines"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.projectionFieldName = (Core.Name "diffLines")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) diff --git a/src/main/haskell/Hydra/Dsl/Build/Format.hs b/src/main/haskell/Hydra/Dsl/Build/Format.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Dsl/Build/Format.hs +++ /dev/null @@ -1,4108 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.build.format - -module Hydra.Dsl.Build.Format where - -import qualified Hydra.Build.Format as Format -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Build.Format as DecodeBuildFormat -import qualified Hydra.Dsl.Packaging as DslPackaging -import qualified Hydra.Encode.Build.Format as EncodeBuildFormat -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typed as Typed -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void -import qualified Data.Map as M - --- | DSL constructor for hydra.build.format.DefinitionNameConventionProfile -definitionNameConventionProfile :: Typed.TypedTerm Format.Severity -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.DefinitionNameConventionProfile -definitionNameConventionProfile severity allowUnderscores = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "severity"), - Core.fieldTerm = (Typed.unTypedTerm severity)}, - Core.Field { - Core.fieldName = (Core.Name "allowUnderscores"), - Core.fieldTerm = (Typed.unTypedTerm allowUnderscores)}]})) - --- | DSL accessor for the allowUnderscores field of hydra.build.format.DefinitionNameConventionProfile -definitionNameConventionProfileAllowUnderscores :: Typed.TypedTerm Format.DefinitionNameConventionProfile -> Typed.TypedTerm Bool -definitionNameConventionProfileAllowUnderscores x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"), - Core.projectionFieldName = (Core.Name "allowUnderscores")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL name token for hydra.build.format.DefinitionNameConventionProfile -definitionNameConventionProfileDefinitionNameConventionProfile :: Typed.TypedName Format.DefinitionNameConventionProfile -definitionNameConventionProfileDefinitionNameConventionProfile = - Typed.TypedName (Core.Name "hydra.build.format.DefinitionNameConventionProfile") - --- | DSL accessor for the severity field of hydra.build.format.DefinitionNameConventionProfile -definitionNameConventionProfileSeverity :: Typed.TypedTerm Format.DefinitionNameConventionProfile -> Typed.TypedTerm Format.Severity -definitionNameConventionProfileSeverity x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"), - Core.projectionFieldName = (Core.Name "severity")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the allowUnderscores field of hydra.build.format.DefinitionNameConventionProfile -definitionNameConventionProfileWithAllowUnderscores :: Typed.TypedTerm Format.DefinitionNameConventionProfile -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.DefinitionNameConventionProfile -definitionNameConventionProfileWithAllowUnderscores original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "severity"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"), - Core.projectionFieldName = (Core.Name "severity")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "allowUnderscores"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL updater for the severity field of hydra.build.format.DefinitionNameConventionProfile -definitionNameConventionProfileWithSeverity :: Typed.TypedTerm Format.DefinitionNameConventionProfile -> Typed.TypedTerm Format.Severity -> Typed.TypedTerm Format.DefinitionNameConventionProfile -definitionNameConventionProfileWithSeverity original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "severity"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "allowUnderscores"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"), - Core.projectionFieldName = (Core.Name "allowUnderscores")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL constructor for hydra.build.format.DefinitionValidationProfile -definitionValidationProfile :: Typed.TypedTerm (Maybe Format.DocumentationProfile) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.DefinitionNameConventionProfile) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.DefinitionValidationProfile -definitionValidationProfile hasDescription ordering nameConvention notInModuleName duplicateName = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "hasDescription"), - Core.fieldTerm = (Typed.unTypedTerm hasDescription)}, - Core.Field { - Core.fieldName = (Core.Name "ordering"), - Core.fieldTerm = (Typed.unTypedTerm ordering)}, - Core.Field { - Core.fieldName = (Core.Name "nameConvention"), - Core.fieldTerm = (Typed.unTypedTerm nameConvention)}, - Core.Field { - Core.fieldName = (Core.Name "notInModuleName"), - Core.fieldTerm = (Typed.unTypedTerm notInModuleName)}, - Core.Field { - Core.fieldName = (Core.Name "duplicateName"), - Core.fieldTerm = (Typed.unTypedTerm duplicateName)}]})) - --- | DSL name token for hydra.build.format.DefinitionValidationProfile -definitionValidationProfileDefinitionValidationProfile :: Typed.TypedName Format.DefinitionValidationProfile -definitionValidationProfileDefinitionValidationProfile = - Typed.TypedName (Core.Name "hydra.build.format.DefinitionValidationProfile") - --- | DSL accessor for the duplicateName field of hydra.build.format.DefinitionValidationProfile -definitionValidationProfileDuplicateName :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -definitionValidationProfileDuplicateName x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "duplicateName")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the hasDescription field of hydra.build.format.DefinitionValidationProfile -definitionValidationProfileHasDescription :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.DocumentationProfile) -definitionValidationProfileHasDescription x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "hasDescription")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the nameConvention field of hydra.build.format.DefinitionValidationProfile -definitionValidationProfileNameConvention :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.DefinitionNameConventionProfile) -definitionValidationProfileNameConvention x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "nameConvention")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the notInModuleName field of hydra.build.format.DefinitionValidationProfile -definitionValidationProfileNotInModuleName :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -definitionValidationProfileNotInModuleName x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "notInModuleName")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the ordering field of hydra.build.format.DefinitionValidationProfile -definitionValidationProfileOrdering :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -definitionValidationProfileOrdering x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "ordering")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the duplicateName field of hydra.build.format.DefinitionValidationProfile -definitionValidationProfileWithDuplicateName :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.DefinitionValidationProfile -definitionValidationProfileWithDuplicateName original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "hasDescription"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "hasDescription")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "ordering"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "ordering")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "nameConvention"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "nameConvention")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "notInModuleName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "notInModuleName")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "duplicateName"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL updater for the hasDescription field of hydra.build.format.DefinitionValidationProfile -definitionValidationProfileWithHasDescription :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.DocumentationProfile) -> Typed.TypedTerm Format.DefinitionValidationProfile -definitionValidationProfileWithHasDescription original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "hasDescription"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "ordering"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "ordering")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "nameConvention"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "nameConvention")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "notInModuleName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "notInModuleName")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "duplicateName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "duplicateName")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the nameConvention field of hydra.build.format.DefinitionValidationProfile -definitionValidationProfileWithNameConvention :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.DefinitionNameConventionProfile) -> Typed.TypedTerm Format.DefinitionValidationProfile -definitionValidationProfileWithNameConvention original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "hasDescription"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "hasDescription")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "ordering"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "ordering")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "nameConvention"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "notInModuleName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "notInModuleName")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "duplicateName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "duplicateName")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the notInModuleName field of hydra.build.format.DefinitionValidationProfile -definitionValidationProfileWithNotInModuleName :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.DefinitionValidationProfile -definitionValidationProfileWithNotInModuleName original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "hasDescription"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "hasDescription")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "ordering"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "ordering")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "nameConvention"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "nameConvention")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "notInModuleName"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "duplicateName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "duplicateName")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the ordering field of hydra.build.format.DefinitionValidationProfile -definitionValidationProfileWithOrdering :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.DefinitionValidationProfile -definitionValidationProfileWithOrdering original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "hasDescription"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "hasDescription")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "ordering"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "nameConvention"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "nameConvention")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "notInModuleName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "notInModuleName")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "duplicateName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.projectionFieldName = (Core.Name "duplicateName")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL constructor for hydra.build.format.DigestEntry -digestEntry :: Typed.TypedTerm Format.DigestKind -> Typed.TypedTerm Format.Sha256Hash -> Typed.TypedTerm Format.DigestEntry -digestEntry kind hash = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.DigestEntry"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "kind"), - Core.fieldTerm = (Typed.unTypedTerm kind)}, - Core.Field { - Core.fieldName = (Core.Name "hash"), - Core.fieldTerm = (Typed.unTypedTerm hash)}]})) - --- | DSL name token for hydra.build.format.DigestEntry -digestEntryDigestEntry :: Typed.TypedName Format.DigestEntry -digestEntryDigestEntry = Typed.TypedName (Core.Name "hydra.build.format.DigestEntry") - --- | DSL accessor for the hash field of hydra.build.format.DigestEntry -digestEntryHash :: Typed.TypedTerm Format.DigestEntry -> Typed.TypedTerm Format.Sha256Hash -digestEntryHash x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DigestEntry"), - Core.projectionFieldName = (Core.Name "hash")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the kind field of hydra.build.format.DigestEntry -digestEntryKind :: Typed.TypedTerm Format.DigestEntry -> Typed.TypedTerm Format.DigestKind -digestEntryKind x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DigestEntry"), - Core.projectionFieldName = (Core.Name "kind")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the hash field of hydra.build.format.DigestEntry -digestEntryWithHash :: Typed.TypedTerm Format.DigestEntry -> Typed.TypedTerm Format.Sha256Hash -> Typed.TypedTerm Format.DigestEntry -digestEntryWithHash original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.DigestEntry"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "kind"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DigestEntry"), - Core.projectionFieldName = (Core.Name "kind")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hash"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL updater for the kind field of hydra.build.format.DigestEntry -digestEntryWithKind :: Typed.TypedTerm Format.DigestEntry -> Typed.TypedTerm Format.DigestKind -> Typed.TypedTerm Format.DigestEntry -digestEntryWithKind original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.DigestEntry"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "kind"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "hash"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DigestEntry"), - Core.projectionFieldName = (Core.Name "hash")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL name token for hydra.build.format.DigestKind -digestKindDigestKind :: Typed.TypedName Format.DigestKind -digestKindDigestKind = Typed.TypedName (Core.Name "hydra.build.format.DigestKind") - --- | DSL injection for the dslSource variant of hydra.build.format.DigestKind -digestKindDslSource :: Typed.TypedTerm Format.DigestKind -digestKindDslSource = - Typed.TypedTerm (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "dslSource"), - Core.fieldTerm = Core.TermUnit}})) - --- | DSL injection for the jsonFile variant of hydra.build.format.DigestKind -digestKindJsonFile :: Typed.TypedTerm Format.DigestKind -digestKindJsonFile = - Typed.TypedTerm (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "jsonFile"), - Core.fieldTerm = Core.TermUnit}})) - --- | DSL injection for the other variant of hydra.build.format.DigestKind -digestKindOther :: Typed.TypedTerm Format.DigestKind -digestKindOther = - Typed.TypedTerm (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "other"), - Core.fieldTerm = Core.TermUnit}})) - --- | DSL injection for the runtimeFile variant of hydra.build.format.DigestKind -digestKindRuntimeFile :: Typed.TypedTerm Format.DigestKind -digestKindRuntimeFile = - Typed.TypedTerm (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "runtimeFile"), - Core.fieldTerm = Core.TermUnit}})) - --- | DSL injection for the targetFile variant of hydra.build.format.DigestKind -digestKindTargetFile :: Typed.TypedTerm Format.DigestKind -digestKindTargetFile = - Typed.TypedTerm (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "targetFile"), - Core.fieldTerm = Core.TermUnit}})) - --- | DSL constructor for hydra.build.format.DocumentationProfile -documentationProfile :: Typed.TypedTerm Format.Severity -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.DocumentationProfile -documentationProfile severity exemptDeprecated = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.DocumentationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "severity"), - Core.fieldTerm = (Typed.unTypedTerm severity)}, - Core.Field { - Core.fieldName = (Core.Name "exemptDeprecated"), - Core.fieldTerm = (Typed.unTypedTerm exemptDeprecated)}]})) - --- | DSL name token for hydra.build.format.DocumentationProfile -documentationProfileDocumentationProfile :: Typed.TypedName Format.DocumentationProfile -documentationProfileDocumentationProfile = Typed.TypedName (Core.Name "hydra.build.format.DocumentationProfile") - --- | DSL accessor for the exemptDeprecated field of hydra.build.format.DocumentationProfile -documentationProfileExemptDeprecated :: Typed.TypedTerm Format.DocumentationProfile -> Typed.TypedTerm Bool -documentationProfileExemptDeprecated x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DocumentationProfile"), - Core.projectionFieldName = (Core.Name "exemptDeprecated")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the severity field of hydra.build.format.DocumentationProfile -documentationProfileSeverity :: Typed.TypedTerm Format.DocumentationProfile -> Typed.TypedTerm Format.Severity -documentationProfileSeverity x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DocumentationProfile"), - Core.projectionFieldName = (Core.Name "severity")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the exemptDeprecated field of hydra.build.format.DocumentationProfile -documentationProfileWithExemptDeprecated :: Typed.TypedTerm Format.DocumentationProfile -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.DocumentationProfile -documentationProfileWithExemptDeprecated original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.DocumentationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "severity"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DocumentationProfile"), - Core.projectionFieldName = (Core.Name "severity")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "exemptDeprecated"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL updater for the severity field of hydra.build.format.DocumentationProfile -documentationProfileWithSeverity :: Typed.TypedTerm Format.DocumentationProfile -> Typed.TypedTerm Format.Severity -> Typed.TypedTerm Format.DocumentationProfile -documentationProfileWithSeverity original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.DocumentationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "severity"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "exemptDeprecated"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.DocumentationProfile"), - Core.projectionFieldName = (Core.Name "exemptDeprecated")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL constructor for hydra.build.format.Generation -generation :: Typed.TypedTerm String -> Typed.TypedTerm Format.GenerationMode -> Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm (Maybe Packaging.Version) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.Generation -generation generatorId mode host hydraVersion revision timestamp = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.Generation"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "generatorId"), - Core.fieldTerm = (Typed.unTypedTerm generatorId)}, - Core.Field { - Core.fieldName = (Core.Name "mode"), - Core.fieldTerm = (Typed.unTypedTerm mode)}, - Core.Field { - Core.fieldName = (Core.Name "host"), - Core.fieldTerm = (Typed.unTypedTerm host)}, - Core.Field { - Core.fieldName = (Core.Name "hydraVersion"), - Core.fieldTerm = (Typed.unTypedTerm hydraVersion)}, - Core.Field { - Core.fieldName = (Core.Name "revision"), - Core.fieldTerm = (Typed.unTypedTerm revision)}, - Core.Field { - Core.fieldName = (Core.Name "timestamp"), - Core.fieldTerm = (Typed.unTypedTerm timestamp)}]})) - --- | DSL name token for hydra.build.format.Generation -generationGeneration :: Typed.TypedName Format.Generation -generationGeneration = Typed.TypedName (Core.Name "hydra.build.format.Generation") - --- | DSL accessor for the generatorId field of hydra.build.format.Generation -generationGeneratorId :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm String -generationGeneratorId x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "generatorId")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the host field of hydra.build.format.Generation -generationHost :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.LanguageName -generationHost x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "host")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the hydraVersion field of hydra.build.format.Generation -generationHydraVersion :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe Packaging.Version) -generationHydraVersion x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "hydraVersion")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the mode field of hydra.build.format.Generation -generationMode :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.GenerationMode -generationMode x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "mode")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL name token for hydra.build.format.GenerationMode -generationModeGenerationMode :: Typed.TypedName Format.GenerationMode -generationModeGenerationMode = Typed.TypedName (Core.Name "hydra.build.format.GenerationMode") - --- | DSL injection for the published variant of hydra.build.format.GenerationMode -generationModePublished :: Typed.TypedTerm Format.GenerationMode -generationModePublished = - Typed.TypedTerm (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.GenerationMode"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "published"), - Core.fieldTerm = Core.TermUnit}})) - --- | DSL injection for the shim variant of hydra.build.format.GenerationMode -generationModeShim :: Typed.TypedTerm Format.GenerationMode -generationModeShim = - Typed.TypedTerm (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.GenerationMode"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "shim"), - Core.fieldTerm = Core.TermUnit}})) - --- | DSL accessor for the revision field of hydra.build.format.Generation -generationRevision :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe String) -generationRevision x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "revision")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the timestamp field of hydra.build.format.Generation -generationTimestamp :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe String) -generationTimestamp x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "timestamp")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the generatorId field of hydra.build.format.Generation -generationWithGeneratorId :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm String -> Typed.TypedTerm Format.Generation -generationWithGeneratorId original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.Generation"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "generatorId"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "mode"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "mode")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "host"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "host")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hydraVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "hydraVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "revision"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "revision")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "timestamp"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "timestamp")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the host field of hydra.build.format.Generation -generationWithHost :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm Format.Generation -generationWithHost original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.Generation"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "generatorId"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "generatorId")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mode"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "mode")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "host"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "hydraVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "hydraVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "revision"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "revision")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "timestamp"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "timestamp")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the hydraVersion field of hydra.build.format.Generation -generationWithHydraVersion :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe Packaging.Version) -> Typed.TypedTerm Format.Generation -generationWithHydraVersion original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.Generation"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "generatorId"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "generatorId")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mode"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "mode")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "host"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "host")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hydraVersion"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "revision"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "revision")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "timestamp"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "timestamp")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the mode field of hydra.build.format.Generation -generationWithMode :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.GenerationMode -> Typed.TypedTerm Format.Generation -generationWithMode original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.Generation"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "generatorId"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "generatorId")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mode"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "host"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "host")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hydraVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "hydraVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "revision"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "revision")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "timestamp"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "timestamp")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the revision field of hydra.build.format.Generation -generationWithRevision :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.Generation -generationWithRevision original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.Generation"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "generatorId"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "generatorId")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mode"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "mode")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "host"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "host")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hydraVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "hydraVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "revision"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "timestamp"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "timestamp")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the timestamp field of hydra.build.format.Generation -generationWithTimestamp :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.Generation -generationWithTimestamp original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.Generation"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "generatorId"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "generatorId")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mode"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "mode")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "host"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "host")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hydraVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "hydraVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "revision"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"), - Core.projectionFieldName = (Core.Name "revision")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "timestamp"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL name token for hydra.build.format.HostOverride -hostOverrideHostOverride :: Typed.TypedName Format.HostOverride -hostOverrideHostOverride = Typed.TypedName (Core.Name "hydra.build.format.HostOverride") - --- | DSL injection for the local variant of hydra.build.format.HostOverride -hostOverrideLocal :: Typed.TypedTerm Format.HostOverride -hostOverrideLocal = - Typed.TypedTerm (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.HostOverride"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "local"), - Core.fieldTerm = Core.TermUnit}})) - --- | DSL injection for the version variant of hydra.build.format.HostOverride -hostOverrideVersion :: Typed.TypedTerm Packaging.Version -> Typed.TypedTerm Format.HostOverride -hostOverrideVersion x = - Typed.TypedTerm (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.HostOverride"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "version"), - Core.fieldTerm = (Typed.unTypedTerm x)}})) - --- | DSL constructor for hydra.build.format.InputDigest -inputDigest :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm (Maybe Format.Sha256Hash) -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) -> Typed.TypedTerm (M.Map Packaging.ModuleName Format.Sha256Hash) -> Typed.TypedTerm Format.InputDigest -inputDigest digestFormatVersion moduleFormatVersion selfHash dependencyHashes moduleHashes = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "digestFormatVersion"), - Core.fieldTerm = (Typed.unTypedTerm digestFormatVersion)}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Typed.unTypedTerm moduleFormatVersion)}, - Core.Field { - Core.fieldName = (Core.Name "selfHash"), - Core.fieldTerm = (Typed.unTypedTerm selfHash)}, - Core.Field { - Core.fieldName = (Core.Name "dependencyHashes"), - Core.fieldTerm = (Typed.unTypedTerm dependencyHashes)}, - Core.Field { - Core.fieldName = (Core.Name "moduleHashes"), - Core.fieldTerm = (Typed.unTypedTerm moduleHashes)}]})) - --- | DSL accessor for the dependencyHashes field of hydra.build.format.InputDigest -inputDigestDependencyHashes :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) -inputDigestDependencyHashes x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "dependencyHashes")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the digestFormatVersion field of hydra.build.format.InputDigest -inputDigestDigestFormatVersion :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm Int -inputDigestDigestFormatVersion x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "digestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL name token for hydra.build.format.InputDigest -inputDigestInputDigest :: Typed.TypedName Format.InputDigest -inputDigestInputDigest = Typed.TypedName (Core.Name "hydra.build.format.InputDigest") - --- | DSL accessor for the moduleFormatVersion field of hydra.build.format.InputDigest -inputDigestModuleFormatVersion :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm Int -inputDigestModuleFormatVersion x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the moduleHashes field of hydra.build.format.InputDigest -inputDigestModuleHashes :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (M.Map Packaging.ModuleName Format.Sha256Hash) -inputDigestModuleHashes x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "moduleHashes")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the selfHash field of hydra.build.format.InputDigest -inputDigestSelfHash :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (Maybe Format.Sha256Hash) -inputDigestSelfHash x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "selfHash")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the dependencyHashes field of hydra.build.format.InputDigest -inputDigestWithDependencyHashes :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) -> Typed.TypedTerm Format.InputDigest -inputDigestWithDependencyHashes original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "digestFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "digestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "selfHash"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "selfHash")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencyHashes"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "moduleHashes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "moduleHashes")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the digestFormatVersion field of hydra.build.format.InputDigest -inputDigestWithDigestFormatVersion :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.InputDigest -inputDigestWithDigestFormatVersion original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "digestFormatVersion"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "selfHash"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "selfHash")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencyHashes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "dependencyHashes")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleHashes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "moduleHashes")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the moduleFormatVersion field of hydra.build.format.InputDigest -inputDigestWithModuleFormatVersion :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.InputDigest -inputDigestWithModuleFormatVersion original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "digestFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "digestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "selfHash"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "selfHash")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencyHashes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "dependencyHashes")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleHashes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "moduleHashes")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the moduleHashes field of hydra.build.format.InputDigest -inputDigestWithModuleHashes :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (M.Map Packaging.ModuleName Format.Sha256Hash) -> Typed.TypedTerm Format.InputDigest -inputDigestWithModuleHashes original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "digestFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "digestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "selfHash"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "selfHash")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencyHashes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "dependencyHashes")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleHashes"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL updater for the selfHash field of hydra.build.format.InputDigest -inputDigestWithSelfHash :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (Maybe Format.Sha256Hash) -> Typed.TypedTerm Format.InputDigest -inputDigestWithSelfHash original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "digestFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "digestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "selfHash"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "dependencyHashes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "dependencyHashes")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleHashes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.projectionFieldName = (Core.Name "moduleHashes")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL constructor for the hydra.build.format.LanguageName wrapper -languageName :: Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageName -languageName x = - Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.build.format.LanguageName"), - Core.wrappedTermBody = (Typed.unTypedTerm x)})) - --- | DSL name token for hydra.build.format.LanguageName -languageNameLanguageName :: Typed.TypedName Format.LanguageName -languageNameLanguageName = Typed.TypedName (Core.Name "hydra.build.format.LanguageName") - --- | DSL constructor for hydra.build.format.LanguageProfile -languageProfile :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile -languageProfile name coderPackage family = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.LanguageProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Typed.unTypedTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "coderPackage"), - Core.fieldTerm = (Typed.unTypedTerm coderPackage)}, - Core.Field { - Core.fieldName = (Core.Name "family"), - Core.fieldTerm = (Typed.unTypedTerm family)}]})) - --- | DSL accessor for the coderPackage field of hydra.build.format.LanguageProfile -languageProfileCoderPackage :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String -languageProfileCoderPackage x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"), - Core.projectionFieldName = (Core.Name "coderPackage")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the family field of hydra.build.format.LanguageProfile -languageProfileFamily :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String -languageProfileFamily x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"), - Core.projectionFieldName = (Core.Name "family")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL name token for hydra.build.format.LanguageProfile -languageProfileLanguageProfile :: Typed.TypedName Format.LanguageProfile -languageProfileLanguageProfile = Typed.TypedName (Core.Name "hydra.build.format.LanguageProfile") - --- | DSL accessor for the name field of hydra.build.format.LanguageProfile -languageProfileName :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String -languageProfileName x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the coderPackage field of hydra.build.format.LanguageProfile -languageProfileWithCoderPackage :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile -languageProfileWithCoderPackage original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.LanguageProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "coderPackage"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "family"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"), - Core.projectionFieldName = (Core.Name "family")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the family field of hydra.build.format.LanguageProfile -languageProfileWithFamily :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile -languageProfileWithFamily original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.LanguageProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "coderPackage"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"), - Core.projectionFieldName = (Core.Name "coderPackage")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "family"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL updater for the name field of hydra.build.format.LanguageProfile -languageProfileWithName :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile -languageProfileWithName original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.LanguageProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "coderPackage"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"), - Core.projectionFieldName = (Core.Name "coderPackage")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "family"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"), - Core.projectionFieldName = (Core.Name "family")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL constructor for hydra.build.format.ModuleValidationProfile -moduleValidationProfile :: Typed.TypedTerm (Maybe Format.DefinitionValidationProfile) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.ModuleValidationProfile -moduleValidationProfile definitions nameConvention conflictingVariantName = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "definitions"), - Core.fieldTerm = (Typed.unTypedTerm definitions)}, - Core.Field { - Core.fieldName = (Core.Name "nameConvention"), - Core.fieldTerm = (Typed.unTypedTerm nameConvention)}, - Core.Field { - Core.fieldName = (Core.Name "conflictingVariantName"), - Core.fieldTerm = (Typed.unTypedTerm conflictingVariantName)}]})) - --- | DSL accessor for the conflictingVariantName field of hydra.build.format.ModuleValidationProfile -moduleValidationProfileConflictingVariantName :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -moduleValidationProfileConflictingVariantName x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"), - Core.projectionFieldName = (Core.Name "conflictingVariantName")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the definitions field of hydra.build.format.ModuleValidationProfile -moduleValidationProfileDefinitions :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.DefinitionValidationProfile) -moduleValidationProfileDefinitions x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"), - Core.projectionFieldName = (Core.Name "definitions")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL name token for hydra.build.format.ModuleValidationProfile -moduleValidationProfileModuleValidationProfile :: Typed.TypedName Format.ModuleValidationProfile -moduleValidationProfileModuleValidationProfile = Typed.TypedName (Core.Name "hydra.build.format.ModuleValidationProfile") - --- | DSL accessor for the nameConvention field of hydra.build.format.ModuleValidationProfile -moduleValidationProfileNameConvention :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -moduleValidationProfileNameConvention x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"), - Core.projectionFieldName = (Core.Name "nameConvention")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the conflictingVariantName field of hydra.build.format.ModuleValidationProfile -moduleValidationProfileWithConflictingVariantName :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.ModuleValidationProfile -moduleValidationProfileWithConflictingVariantName original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "definitions"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"), - Core.projectionFieldName = (Core.Name "definitions")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "nameConvention"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"), - Core.projectionFieldName = (Core.Name "nameConvention")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "conflictingVariantName"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL updater for the definitions field of hydra.build.format.ModuleValidationProfile -moduleValidationProfileWithDefinitions :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.DefinitionValidationProfile) -> Typed.TypedTerm Format.ModuleValidationProfile -moduleValidationProfileWithDefinitions original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "definitions"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "nameConvention"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"), - Core.projectionFieldName = (Core.Name "nameConvention")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "conflictingVariantName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"), - Core.projectionFieldName = (Core.Name "conflictingVariantName")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the nameConvention field of hydra.build.format.ModuleValidationProfile -moduleValidationProfileWithNameConvention :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.ModuleValidationProfile -moduleValidationProfileWithNameConvention original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "definitions"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"), - Core.projectionFieldName = (Core.Name "definitions")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "nameConvention"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "conflictingVariantName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"), - Core.projectionFieldName = (Core.Name "conflictingVariantName")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL constructor for hydra.build.format.OutputDigest -outputDigest :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm String -> Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe Format.Sha256Hash) -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) -> Typed.TypedTerm (M.Map String Format.DigestEntry) -> Typed.TypedTerm (M.Map String Format.DigestEntry) -> Typed.TypedTerm Format.OutputDigest -outputDigest digestFormatVersion moduleFormatVersion generator generation selfHash dependencyHashes inputs outputs = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "digestFormatVersion"), - Core.fieldTerm = (Typed.unTypedTerm digestFormatVersion)}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Typed.unTypedTerm moduleFormatVersion)}, - Core.Field { - Core.fieldName = (Core.Name "generator"), - Core.fieldTerm = (Typed.unTypedTerm generator)}, - Core.Field { - Core.fieldName = (Core.Name "generation"), - Core.fieldTerm = (Typed.unTypedTerm generation)}, - Core.Field { - Core.fieldName = (Core.Name "selfHash"), - Core.fieldTerm = (Typed.unTypedTerm selfHash)}, - Core.Field { - Core.fieldName = (Core.Name "dependencyHashes"), - Core.fieldTerm = (Typed.unTypedTerm dependencyHashes)}, - Core.Field { - Core.fieldName = (Core.Name "inputs"), - Core.fieldTerm = (Typed.unTypedTerm inputs)}, - Core.Field { - Core.fieldName = (Core.Name "outputs"), - Core.fieldTerm = (Typed.unTypedTerm outputs)}]})) - --- | DSL accessor for the dependencyHashes field of hydra.build.format.OutputDigest -outputDigestDependencyHashes :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) -outputDigestDependencyHashes x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "dependencyHashes")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the digestFormatVersion field of hydra.build.format.OutputDigest -outputDigestDigestFormatVersion :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Int -outputDigestDigestFormatVersion x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "digestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the generation field of hydra.build.format.OutputDigest -outputDigestGeneration :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Format.Generation -outputDigestGeneration x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "generation")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the generator field of hydra.build.format.OutputDigest -outputDigestGenerator :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm String -outputDigestGenerator x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "generator")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the inputs field of hydra.build.format.OutputDigest -outputDigestInputs :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map String Format.DigestEntry) -outputDigestInputs x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "inputs")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the moduleFormatVersion field of hydra.build.format.OutputDigest -outputDigestModuleFormatVersion :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Int -outputDigestModuleFormatVersion x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL name token for hydra.build.format.OutputDigest -outputDigestOutputDigest :: Typed.TypedName Format.OutputDigest -outputDigestOutputDigest = Typed.TypedName (Core.Name "hydra.build.format.OutputDigest") - --- | DSL accessor for the outputs field of hydra.build.format.OutputDigest -outputDigestOutputs :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map String Format.DigestEntry) -outputDigestOutputs x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "outputs")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the selfHash field of hydra.build.format.OutputDigest -outputDigestSelfHash :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (Maybe Format.Sha256Hash) -outputDigestSelfHash x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "selfHash")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the dependencyHashes field of hydra.build.format.OutputDigest -outputDigestWithDependencyHashes :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) -> Typed.TypedTerm Format.OutputDigest -outputDigestWithDependencyHashes original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "digestFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "digestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "generator"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "generator")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "generation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "generation")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "selfHash"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "selfHash")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencyHashes"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "inputs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "inputs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "outputs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "outputs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the digestFormatVersion field of hydra.build.format.OutputDigest -outputDigestWithDigestFormatVersion :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.OutputDigest -outputDigestWithDigestFormatVersion original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "digestFormatVersion"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "generator"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "generator")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "generation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "generation")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "selfHash"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "selfHash")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencyHashes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "dependencyHashes")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "inputs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "inputs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "outputs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "outputs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the generation field of hydra.build.format.OutputDigest -outputDigestWithGeneration :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.OutputDigest -outputDigestWithGeneration original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "digestFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "digestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "generator"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "generator")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "generation"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "selfHash"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "selfHash")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencyHashes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "dependencyHashes")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "inputs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "inputs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "outputs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "outputs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the generator field of hydra.build.format.OutputDigest -outputDigestWithGenerator :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm String -> Typed.TypedTerm Format.OutputDigest -outputDigestWithGenerator original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "digestFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "digestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "generator"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "generation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "generation")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "selfHash"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "selfHash")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencyHashes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "dependencyHashes")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "inputs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "inputs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "outputs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "outputs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the inputs field of hydra.build.format.OutputDigest -outputDigestWithInputs :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map String Format.DigestEntry) -> Typed.TypedTerm Format.OutputDigest -outputDigestWithInputs original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "digestFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "digestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "generator"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "generator")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "generation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "generation")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "selfHash"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "selfHash")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencyHashes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "dependencyHashes")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "inputs"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "outputs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "outputs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the moduleFormatVersion field of hydra.build.format.OutputDigest -outputDigestWithModuleFormatVersion :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.OutputDigest -outputDigestWithModuleFormatVersion original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "digestFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "digestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "generator"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "generator")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "generation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "generation")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "selfHash"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "selfHash")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencyHashes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "dependencyHashes")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "inputs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "inputs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "outputs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "outputs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the outputs field of hydra.build.format.OutputDigest -outputDigestWithOutputs :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map String Format.DigestEntry) -> Typed.TypedTerm Format.OutputDigest -outputDigestWithOutputs original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "digestFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "digestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "generator"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "generator")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "generation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "generation")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "selfHash"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "selfHash")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencyHashes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "dependencyHashes")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "inputs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "inputs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "outputs"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL updater for the selfHash field of hydra.build.format.OutputDigest -outputDigestWithSelfHash :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (Maybe Format.Sha256Hash) -> Typed.TypedTerm Format.OutputDigest -outputDigestWithSelfHash original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "digestFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "digestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "generator"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "generator")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "generation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "generation")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "selfHash"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "dependencyHashes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "dependencyHashes")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "inputs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "inputs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "outputs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.projectionFieldName = (Core.Name "outputs")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL constructor for hydra.build.format.PackageDescriptor -packageDescriptor :: Typed.TypedTerm Int -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm (Maybe [Format.LanguageName]) -> Typed.TypedTerm [Packaging.PackageName] -> Typed.TypedTerm (Maybe Format.PackageValidationConfiguration) -> Typed.TypedTerm Format.PackageDescriptor -packageDescriptor packageFormatVersion name description sourceLanguage targetLanguages dependencies validation = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "packageFormatVersion"), - Core.fieldTerm = (Typed.unTypedTerm packageFormatVersion)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Typed.unTypedTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Typed.unTypedTerm description)}, - Core.Field { - Core.fieldName = (Core.Name "sourceLanguage"), - Core.fieldTerm = (Typed.unTypedTerm sourceLanguage)}, - Core.Field { - Core.fieldName = (Core.Name "targetLanguages"), - Core.fieldTerm = (Typed.unTypedTerm targetLanguages)}, - Core.Field { - Core.fieldName = (Core.Name "dependencies"), - Core.fieldTerm = (Typed.unTypedTerm dependencies)}, - Core.Field { - Core.fieldName = (Core.Name "validation"), - Core.fieldTerm = (Typed.unTypedTerm validation)}]})) - --- | DSL accessor for the dependencies field of hydra.build.format.PackageDescriptor -packageDescriptorDependencies :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm [Packaging.PackageName] -packageDescriptorDependencies x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "dependencies")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the description field of hydra.build.format.PackageDescriptor -packageDescriptorDescription :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm String -packageDescriptorDescription x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "description")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the name field of hydra.build.format.PackageDescriptor -packageDescriptorName :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Packaging.PackageName -packageDescriptorName x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL name token for hydra.build.format.PackageDescriptor -packageDescriptorPackageDescriptor :: Typed.TypedName Format.PackageDescriptor -packageDescriptorPackageDescriptor = Typed.TypedName (Core.Name "hydra.build.format.PackageDescriptor") - --- | DSL accessor for the packageFormatVersion field of hydra.build.format.PackageDescriptor -packageDescriptorPackageFormatVersion :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Int -packageDescriptorPackageFormatVersion x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "packageFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the sourceLanguage field of hydra.build.format.PackageDescriptor -packageDescriptorSourceLanguage :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Format.LanguageName -packageDescriptorSourceLanguage x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "sourceLanguage")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the targetLanguages field of hydra.build.format.PackageDescriptor -packageDescriptorTargetLanguages :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm (Maybe [Format.LanguageName]) -packageDescriptorTargetLanguages x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "targetLanguages")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the validation field of hydra.build.format.PackageDescriptor -packageDescriptorValidation :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm (Maybe Format.PackageValidationConfiguration) -packageDescriptorValidation x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "validation")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the dependencies field of hydra.build.format.PackageDescriptor -packageDescriptorWithDependencies :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm [Packaging.PackageName] -> Typed.TypedTerm Format.PackageDescriptor -packageDescriptorWithDependencies original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "packageFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "packageFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "description")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "sourceLanguage"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "sourceLanguage")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "targetLanguages"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "targetLanguages")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencies"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "validation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "validation")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the description field of hydra.build.format.PackageDescriptor -packageDescriptorWithDescription :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.PackageDescriptor -packageDescriptorWithDescription original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "packageFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "packageFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "sourceLanguage"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "sourceLanguage")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "targetLanguages"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "targetLanguages")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencies"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "dependencies")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "validation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "validation")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the name field of hydra.build.format.PackageDescriptor -packageDescriptorWithName :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm Format.PackageDescriptor -packageDescriptorWithName original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "packageFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "packageFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "description")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "sourceLanguage"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "sourceLanguage")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "targetLanguages"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "targetLanguages")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencies"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "dependencies")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "validation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "validation")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the packageFormatVersion field of hydra.build.format.PackageDescriptor -packageDescriptorWithPackageFormatVersion :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PackageDescriptor -packageDescriptorWithPackageFormatVersion original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "packageFormatVersion"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "description")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "sourceLanguage"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "sourceLanguage")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "targetLanguages"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "targetLanguages")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencies"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "dependencies")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "validation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "validation")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the sourceLanguage field of hydra.build.format.PackageDescriptor -packageDescriptorWithSourceLanguage :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm Format.PackageDescriptor -packageDescriptorWithSourceLanguage original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "packageFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "packageFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "description")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "sourceLanguage"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "targetLanguages"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "targetLanguages")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencies"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "dependencies")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "validation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "validation")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the targetLanguages field of hydra.build.format.PackageDescriptor -packageDescriptorWithTargetLanguages :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm (Maybe [Format.LanguageName]) -> Typed.TypedTerm Format.PackageDescriptor -packageDescriptorWithTargetLanguages original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "packageFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "packageFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "description")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "sourceLanguage"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "sourceLanguage")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "targetLanguages"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "dependencies"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "dependencies")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "validation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "validation")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the validation field of hydra.build.format.PackageDescriptor -packageDescriptorWithValidation :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm (Maybe Format.PackageValidationConfiguration) -> Typed.TypedTerm Format.PackageDescriptor -packageDescriptorWithValidation original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "packageFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "packageFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "description")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "sourceLanguage"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "sourceLanguage")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "targetLanguages"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "targetLanguages")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencies"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.projectionFieldName = (Core.Name "dependencies")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "validation"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL constructor for hydra.build.format.PackageManifest -packageManifest :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest -packageManifest manifestFormatVersion moduleFormatVersion package mainModules testModules mainDslModules mainEncodingModules = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "manifestFormatVersion"), - Core.fieldTerm = (Typed.unTypedTerm manifestFormatVersion)}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Typed.unTypedTerm moduleFormatVersion)}, - Core.Field { - Core.fieldName = (Core.Name "package"), - Core.fieldTerm = (Typed.unTypedTerm package)}, - Core.Field { - Core.fieldName = (Core.Name "mainModules"), - Core.fieldTerm = (Typed.unTypedTerm mainModules)}, - Core.Field { - Core.fieldName = (Core.Name "testModules"), - Core.fieldTerm = (Typed.unTypedTerm testModules)}, - Core.Field { - Core.fieldName = (Core.Name "mainDslModules"), - Core.fieldTerm = (Typed.unTypedTerm mainDslModules)}, - Core.Field { - Core.fieldName = (Core.Name "mainEncodingModules"), - Core.fieldTerm = (Typed.unTypedTerm mainEncodingModules)}]})) - --- | DSL accessor for the mainDslModules field of hydra.build.format.PackageManifest -packageManifestMainDslModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -packageManifestMainDslModules x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainDslModules")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the mainEncodingModules field of hydra.build.format.PackageManifest -packageManifestMainEncodingModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -packageManifestMainEncodingModules x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainEncodingModules")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the mainModules field of hydra.build.format.PackageManifest -packageManifestMainModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -packageManifestMainModules x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainModules")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the manifestFormatVersion field of hydra.build.format.PackageManifest -packageManifestManifestFormatVersion :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Int -packageManifestManifestFormatVersion x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "manifestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the moduleFormatVersion field of hydra.build.format.PackageManifest -packageManifestModuleFormatVersion :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Int -packageManifestModuleFormatVersion x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the package field of hydra.build.format.PackageManifest -packageManifestPackage :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Packaging.PackageName -packageManifestPackage x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "package")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL name token for hydra.build.format.PackageManifest -packageManifestPackageManifest :: Typed.TypedName Format.PackageManifest -packageManifestPackageManifest = Typed.TypedName (Core.Name "hydra.build.format.PackageManifest") - --- | DSL accessor for the testModules field of hydra.build.format.PackageManifest -packageManifestTestModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -packageManifestTestModules x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "testModules")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the mainDslModules field of hydra.build.format.PackageManifest -packageManifestWithMainDslModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest -packageManifestWithMainDslModules original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "manifestFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "manifestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "package"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "package")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mainModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "testModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mainDslModules"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "mainEncodingModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainEncodingModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the mainEncodingModules field of hydra.build.format.PackageManifest -packageManifestWithMainEncodingModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest -packageManifestWithMainEncodingModules original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "manifestFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "manifestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "package"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "package")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mainModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "testModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mainDslModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainDslModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mainEncodingModules"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL updater for the mainModules field of hydra.build.format.PackageManifest -packageManifestWithMainModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest -packageManifestWithMainModules original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "manifestFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "manifestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "package"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "package")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mainModules"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "testModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "testModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mainDslModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainDslModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mainEncodingModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainEncodingModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the manifestFormatVersion field of hydra.build.format.PackageManifest -packageManifestWithManifestFormatVersion :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PackageManifest -packageManifestWithManifestFormatVersion original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "manifestFormatVersion"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "package"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "package")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mainModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "testModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mainDslModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainDslModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mainEncodingModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainEncodingModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the moduleFormatVersion field of hydra.build.format.PackageManifest -packageManifestWithModuleFormatVersion :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PackageManifest -packageManifestWithModuleFormatVersion original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "manifestFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "manifestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "package"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "package")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mainModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "testModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mainDslModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainDslModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mainEncodingModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainEncodingModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the package field of hydra.build.format.PackageManifest -packageManifestWithPackage :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm Format.PackageManifest -packageManifestWithPackage original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "manifestFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "manifestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "package"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "mainModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "testModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mainDslModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainDslModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mainEncodingModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainEncodingModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the testModules field of hydra.build.format.PackageManifest -packageManifestWithTestModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest -packageManifestWithTestModules original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "manifestFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "manifestFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "moduleFormatVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "package"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "package")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mainModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testModules"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "mainDslModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainDslModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mainEncodingModules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.projectionFieldName = (Core.Name "mainEncodingModules")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL constructor for hydra.build.format.PackageValidationConfiguration -packageValidationConfiguration :: Typed.TypedTerm (Maybe Format.PackageValidationProfile) -> Typed.TypedTerm (Maybe Format.ModuleValidationProfile) -> Typed.TypedTerm (Maybe Format.TypeValidationProfile) -> Typed.TypedTerm (Maybe Format.TermValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration -packageValidationConfiguration package module_ type_ term = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "package"), - Core.fieldTerm = (Typed.unTypedTerm package)}, - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = (Typed.unTypedTerm module_)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Typed.unTypedTerm type_)}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Typed.unTypedTerm term)}]})) - --- | DSL accessor for the module field of hydra.build.format.PackageValidationConfiguration -packageValidationConfigurationModule :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.ModuleValidationProfile) -packageValidationConfigurationModule x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.projectionFieldName = (Core.Name "module")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the package field of hydra.build.format.PackageValidationConfiguration -packageValidationConfigurationPackage :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.PackageValidationProfile) -packageValidationConfigurationPackage x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.projectionFieldName = (Core.Name "package")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL name token for hydra.build.format.PackageValidationConfiguration -packageValidationConfigurationPackageValidationConfiguration :: Typed.TypedName Format.PackageValidationConfiguration -packageValidationConfigurationPackageValidationConfiguration = - Typed.TypedName (Core.Name "hydra.build.format.PackageValidationConfiguration") - --- | DSL accessor for the term field of hydra.build.format.PackageValidationConfiguration -packageValidationConfigurationTerm :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.TermValidationProfile) -packageValidationConfigurationTerm x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the type field of hydra.build.format.PackageValidationConfiguration -packageValidationConfigurationType :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.TypeValidationProfile) -packageValidationConfigurationType x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.projectionFieldName = (Core.Name "type")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the module field of hydra.build.format.PackageValidationConfiguration -packageValidationConfigurationWithModule :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.ModuleValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration -packageValidationConfigurationWithModule original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "package"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.projectionFieldName = (Core.Name "package")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.projectionFieldName = (Core.Name "type")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the package field of hydra.build.format.PackageValidationConfiguration -packageValidationConfigurationWithPackage :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.PackageValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration -packageValidationConfigurationWithPackage original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "package"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.projectionFieldName = (Core.Name "module")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.projectionFieldName = (Core.Name "type")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the term field of hydra.build.format.PackageValidationConfiguration -packageValidationConfigurationWithTerm :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.TermValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration -packageValidationConfigurationWithTerm original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "package"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.projectionFieldName = (Core.Name "package")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.projectionFieldName = (Core.Name "module")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.projectionFieldName = (Core.Name "type")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL updater for the type field of hydra.build.format.PackageValidationConfiguration -packageValidationConfigurationWithType :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.TypeValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration -packageValidationConfigurationWithType original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "package"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.projectionFieldName = (Core.Name "package")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.projectionFieldName = (Core.Name "module")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL constructor for hydra.build.format.PackageValidationProfile -packageValidationProfile :: Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.PackageValidationProfile -packageValidationProfile conflictingModuleName duplicateModuleName nameConvention = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "conflictingModuleName"), - Core.fieldTerm = (Typed.unTypedTerm conflictingModuleName)}, - Core.Field { - Core.fieldName = (Core.Name "duplicateModuleName"), - Core.fieldTerm = (Typed.unTypedTerm duplicateModuleName)}, - Core.Field { - Core.fieldName = (Core.Name "nameConvention"), - Core.fieldTerm = (Typed.unTypedTerm nameConvention)}]})) - --- | DSL accessor for the conflictingModuleName field of hydra.build.format.PackageValidationProfile -packageValidationProfileConflictingModuleName :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -packageValidationProfileConflictingModuleName x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"), - Core.projectionFieldName = (Core.Name "conflictingModuleName")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the duplicateModuleName field of hydra.build.format.PackageValidationProfile -packageValidationProfileDuplicateModuleName :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -packageValidationProfileDuplicateModuleName x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"), - Core.projectionFieldName = (Core.Name "duplicateModuleName")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the nameConvention field of hydra.build.format.PackageValidationProfile -packageValidationProfileNameConvention :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -packageValidationProfileNameConvention x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"), - Core.projectionFieldName = (Core.Name "nameConvention")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL name token for hydra.build.format.PackageValidationProfile -packageValidationProfilePackageValidationProfile :: Typed.TypedName Format.PackageValidationProfile -packageValidationProfilePackageValidationProfile = - Typed.TypedName (Core.Name "hydra.build.format.PackageValidationProfile") - --- | DSL updater for the conflictingModuleName field of hydra.build.format.PackageValidationProfile -packageValidationProfileWithConflictingModuleName :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.PackageValidationProfile -packageValidationProfileWithConflictingModuleName original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "conflictingModuleName"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "duplicateModuleName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"), - Core.projectionFieldName = (Core.Name "duplicateModuleName")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "nameConvention"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"), - Core.projectionFieldName = (Core.Name "nameConvention")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the duplicateModuleName field of hydra.build.format.PackageValidationProfile -packageValidationProfileWithDuplicateModuleName :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.PackageValidationProfile -packageValidationProfileWithDuplicateModuleName original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "conflictingModuleName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"), - Core.projectionFieldName = (Core.Name "conflictingModuleName")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "duplicateModuleName"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "nameConvention"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"), - Core.projectionFieldName = (Core.Name "nameConvention")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the nameConvention field of hydra.build.format.PackageValidationProfile -packageValidationProfileWithNameConvention :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.PackageValidationProfile -packageValidationProfileWithNameConvention original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "conflictingModuleName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"), - Core.projectionFieldName = (Core.Name "conflictingModuleName")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "duplicateModuleName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"), - Core.projectionFieldName = (Core.Name "duplicateModuleName")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "nameConvention"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL constructor for hydra.build.format.RepositoryDescriptor -repositoryDescriptor :: Typed.TypedTerm Packaging.Version -> Typed.TypedTerm Packaging.Version -> Typed.TypedTerm (M.Map Format.LanguageName Format.HostOverride) -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm [Packaging.PackageName] -> Typed.TypedTerm Format.RepositoryDescriptor -repositoryDescriptor currentVersion hostVersion hostOverrides group author url license packages = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "currentVersion"), - Core.fieldTerm = (Typed.unTypedTerm currentVersion)}, - Core.Field { - Core.fieldName = (Core.Name "hostVersion"), - Core.fieldTerm = (Typed.unTypedTerm hostVersion)}, - Core.Field { - Core.fieldName = (Core.Name "hostOverrides"), - Core.fieldTerm = (Typed.unTypedTerm hostOverrides)}, - Core.Field { - Core.fieldName = (Core.Name "group"), - Core.fieldTerm = (Typed.unTypedTerm group)}, - Core.Field { - Core.fieldName = (Core.Name "author"), - Core.fieldTerm = (Typed.unTypedTerm author)}, - Core.Field { - Core.fieldName = (Core.Name "url"), - Core.fieldTerm = (Typed.unTypedTerm url)}, - Core.Field { - Core.fieldName = (Core.Name "license"), - Core.fieldTerm = (Typed.unTypedTerm license)}, - Core.Field { - Core.fieldName = (Core.Name "packages"), - Core.fieldTerm = (Typed.unTypedTerm packages)}]})) - --- | DSL accessor for the author field of hydra.build.format.RepositoryDescriptor -repositoryDescriptorAuthor :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -repositoryDescriptorAuthor x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "author")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the currentVersion field of hydra.build.format.RepositoryDescriptor -repositoryDescriptorCurrentVersion :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm Packaging.Version -repositoryDescriptorCurrentVersion x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "currentVersion")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the group field of hydra.build.format.RepositoryDescriptor -repositoryDescriptorGroup :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -repositoryDescriptorGroup x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "group")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the hostOverrides field of hydra.build.format.RepositoryDescriptor -repositoryDescriptorHostOverrides :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm (M.Map Format.LanguageName Format.HostOverride) -repositoryDescriptorHostOverrides x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "hostOverrides")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the hostVersion field of hydra.build.format.RepositoryDescriptor -repositoryDescriptorHostVersion :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm Packaging.Version -repositoryDescriptorHostVersion x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "hostVersion")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the license field of hydra.build.format.RepositoryDescriptor -repositoryDescriptorLicense :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -repositoryDescriptorLicense x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "license")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the packages field of hydra.build.format.RepositoryDescriptor -repositoryDescriptorPackages :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm [Packaging.PackageName] -repositoryDescriptorPackages x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "packages")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL name token for hydra.build.format.RepositoryDescriptor -repositoryDescriptorRepositoryDescriptor :: Typed.TypedName Format.RepositoryDescriptor -repositoryDescriptorRepositoryDescriptor = Typed.TypedName (Core.Name "hydra.build.format.RepositoryDescriptor") - --- | DSL accessor for the url field of hydra.build.format.RepositoryDescriptor -repositoryDescriptorUrl :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -repositoryDescriptorUrl x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "url")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the author field of hydra.build.format.RepositoryDescriptor -repositoryDescriptorWithAuthor :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.RepositoryDescriptor -repositoryDescriptorWithAuthor original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "currentVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "currentVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hostVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "hostVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hostOverrides"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "hostOverrides")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "group"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "group")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "author"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "url"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "url")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "license"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "license")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "packages"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "packages")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the currentVersion field of hydra.build.format.RepositoryDescriptor -repositoryDescriptorWithCurrentVersion :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm Packaging.Version -> Typed.TypedTerm Format.RepositoryDescriptor -repositoryDescriptorWithCurrentVersion original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "currentVersion"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "hostVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "hostVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hostOverrides"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "hostOverrides")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "group"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "group")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "author"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "author")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "url"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "url")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "license"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "license")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "packages"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "packages")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the group field of hydra.build.format.RepositoryDescriptor -repositoryDescriptorWithGroup :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.RepositoryDescriptor -repositoryDescriptorWithGroup original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "currentVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "currentVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hostVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "hostVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hostOverrides"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "hostOverrides")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "group"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "author"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "author")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "url"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "url")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "license"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "license")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "packages"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "packages")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the hostOverrides field of hydra.build.format.RepositoryDescriptor -repositoryDescriptorWithHostOverrides :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm (M.Map Format.LanguageName Format.HostOverride) -> Typed.TypedTerm Format.RepositoryDescriptor -repositoryDescriptorWithHostOverrides original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "currentVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "currentVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hostVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "hostVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hostOverrides"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "group"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "group")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "author"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "author")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "url"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "url")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "license"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "license")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "packages"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "packages")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the hostVersion field of hydra.build.format.RepositoryDescriptor -repositoryDescriptorWithHostVersion :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm Packaging.Version -> Typed.TypedTerm Format.RepositoryDescriptor -repositoryDescriptorWithHostVersion original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "currentVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "currentVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hostVersion"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "hostOverrides"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "hostOverrides")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "group"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "group")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "author"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "author")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "url"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "url")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "license"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "license")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "packages"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "packages")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the license field of hydra.build.format.RepositoryDescriptor -repositoryDescriptorWithLicense :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.RepositoryDescriptor -repositoryDescriptorWithLicense original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "currentVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "currentVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hostVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "hostVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hostOverrides"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "hostOverrides")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "group"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "group")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "author"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "author")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "url"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "url")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "license"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "packages"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "packages")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the packages field of hydra.build.format.RepositoryDescriptor -repositoryDescriptorWithPackages :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm [Packaging.PackageName] -> Typed.TypedTerm Format.RepositoryDescriptor -repositoryDescriptorWithPackages original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "currentVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "currentVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hostVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "hostVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hostOverrides"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "hostOverrides")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "group"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "group")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "author"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "author")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "url"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "url")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "license"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "license")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "packages"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL updater for the url field of hydra.build.format.RepositoryDescriptor -repositoryDescriptorWithUrl :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.RepositoryDescriptor -repositoryDescriptorWithUrl original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "currentVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "currentVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hostVersion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "hostVersion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "hostOverrides"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "hostOverrides")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "group"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "group")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "author"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "author")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "url"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "license"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "license")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "packages"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.projectionFieldName = (Core.Name "packages")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL injection for the error variant of hydra.build.format.Severity -severityError :: Typed.TypedTerm Format.Severity -severityError = - Typed.TypedTerm (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.Severity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "error"), - Core.fieldTerm = Core.TermUnit}})) - --- | DSL name token for hydra.build.format.Severity -severitySeverity :: Typed.TypedName Format.Severity -severitySeverity = Typed.TypedName (Core.Name "hydra.build.format.Severity") - --- | DSL injection for the warning variant of hydra.build.format.Severity -severityWarning :: Typed.TypedTerm Format.Severity -severityWarning = - Typed.TypedTerm (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.Severity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "warning"), - Core.fieldTerm = Core.TermUnit}})) - --- | DSL constructor for the hydra.build.format.Sha256Hash wrapper -sha256Hash :: Typed.TypedTerm String -> Typed.TypedTerm Format.Sha256Hash -sha256Hash x = - Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.build.format.Sha256Hash"), - Core.wrappedTermBody = (Typed.unTypedTerm x)})) - --- | DSL name token for hydra.build.format.Sha256Hash -sha256HashSha256Hash :: Typed.TypedName Format.Sha256Hash -sha256HashSha256Hash = Typed.TypedName (Core.Name "hydra.build.format.Sha256Hash") - --- | DSL constructor for hydra.build.format.TermValidationProfile -termValidationProfile :: Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TermValidationProfile -termValidationProfile duplicateBinding emptyTermAnnotation undefinedVariable = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.TermValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "duplicateBinding"), - Core.fieldTerm = (Typed.unTypedTerm duplicateBinding)}, - Core.Field { - Core.fieldName = (Core.Name "emptyTermAnnotation"), - Core.fieldTerm = (Typed.unTypedTerm emptyTermAnnotation)}, - Core.Field { - Core.fieldName = (Core.Name "undefinedVariable"), - Core.fieldTerm = (Typed.unTypedTerm undefinedVariable)}]})) - --- | DSL accessor for the duplicateBinding field of hydra.build.format.TermValidationProfile -termValidationProfileDuplicateBinding :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -termValidationProfileDuplicateBinding x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"), - Core.projectionFieldName = (Core.Name "duplicateBinding")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the emptyTermAnnotation field of hydra.build.format.TermValidationProfile -termValidationProfileEmptyTermAnnotation :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -termValidationProfileEmptyTermAnnotation x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"), - Core.projectionFieldName = (Core.Name "emptyTermAnnotation")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL name token for hydra.build.format.TermValidationProfile -termValidationProfileTermValidationProfile :: Typed.TypedName Format.TermValidationProfile -termValidationProfileTermValidationProfile = Typed.TypedName (Core.Name "hydra.build.format.TermValidationProfile") - --- | DSL accessor for the undefinedVariable field of hydra.build.format.TermValidationProfile -termValidationProfileUndefinedVariable :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -termValidationProfileUndefinedVariable x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"), - Core.projectionFieldName = (Core.Name "undefinedVariable")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL updater for the duplicateBinding field of hydra.build.format.TermValidationProfile -termValidationProfileWithDuplicateBinding :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TermValidationProfile -termValidationProfileWithDuplicateBinding original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.TermValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "duplicateBinding"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "emptyTermAnnotation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"), - Core.projectionFieldName = (Core.Name "emptyTermAnnotation")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "undefinedVariable"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"), - Core.projectionFieldName = (Core.Name "undefinedVariable")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the emptyTermAnnotation field of hydra.build.format.TermValidationProfile -termValidationProfileWithEmptyTermAnnotation :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TermValidationProfile -termValidationProfileWithEmptyTermAnnotation original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.TermValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "duplicateBinding"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"), - Core.projectionFieldName = (Core.Name "duplicateBinding")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "emptyTermAnnotation"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "undefinedVariable"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"), - Core.projectionFieldName = (Core.Name "undefinedVariable")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the undefinedVariable field of hydra.build.format.TermValidationProfile -termValidationProfileWithUndefinedVariable :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TermValidationProfile -termValidationProfileWithUndefinedVariable original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.TermValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "duplicateBinding"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"), - Core.projectionFieldName = (Core.Name "duplicateBinding")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "emptyTermAnnotation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"), - Core.projectionFieldName = (Core.Name "emptyTermAnnotation")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "undefinedVariable"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL constructor for hydra.build.format.TypeValidationProfile -typeValidationProfile :: Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TypeValidationProfile -typeValidationProfile emptyAnnotation duplicateField singleVariantUnion = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "emptyAnnotation"), - Core.fieldTerm = (Typed.unTypedTerm emptyAnnotation)}, - Core.Field { - Core.fieldName = (Core.Name "duplicateField"), - Core.fieldTerm = (Typed.unTypedTerm duplicateField)}, - Core.Field { - Core.fieldName = (Core.Name "singleVariantUnion"), - Core.fieldTerm = (Typed.unTypedTerm singleVariantUnion)}]})) - --- | DSL accessor for the duplicateField field of hydra.build.format.TypeValidationProfile -typeValidationProfileDuplicateField :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -typeValidationProfileDuplicateField x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"), - Core.projectionFieldName = (Core.Name "duplicateField")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the emptyAnnotation field of hydra.build.format.TypeValidationProfile -typeValidationProfileEmptyAnnotation :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -typeValidationProfileEmptyAnnotation x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"), - Core.projectionFieldName = (Core.Name "emptyAnnotation")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the singleVariantUnion field of hydra.build.format.TypeValidationProfile -typeValidationProfileSingleVariantUnion :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -typeValidationProfileSingleVariantUnion x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"), - Core.projectionFieldName = (Core.Name "singleVariantUnion")})), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL name token for hydra.build.format.TypeValidationProfile -typeValidationProfileTypeValidationProfile :: Typed.TypedName Format.TypeValidationProfile -typeValidationProfileTypeValidationProfile = Typed.TypedName (Core.Name "hydra.build.format.TypeValidationProfile") - --- | DSL updater for the duplicateField field of hydra.build.format.TypeValidationProfile -typeValidationProfileWithDuplicateField :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TypeValidationProfile -typeValidationProfileWithDuplicateField original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "emptyAnnotation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"), - Core.projectionFieldName = (Core.Name "emptyAnnotation")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "duplicateField"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "singleVariantUnion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"), - Core.projectionFieldName = (Core.Name "singleVariantUnion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the emptyAnnotation field of hydra.build.format.TypeValidationProfile -typeValidationProfileWithEmptyAnnotation :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TypeValidationProfile -typeValidationProfileWithEmptyAnnotation original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "emptyAnnotation"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "duplicateField"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"), - Core.projectionFieldName = (Core.Name "duplicateField")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "singleVariantUnion"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"), - Core.projectionFieldName = (Core.Name "singleVariantUnion")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) - --- | DSL updater for the singleVariantUnion field of hydra.build.format.TypeValidationProfile -typeValidationProfileWithSingleVariantUnion :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TypeValidationProfile -typeValidationProfileWithSingleVariantUnion original newVal = - Typed.TypedTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "emptyAnnotation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"), - Core.projectionFieldName = (Core.Name "emptyAnnotation")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "duplicateField"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"), - Core.projectionFieldName = (Core.Name "duplicateField")})), - Core.applicationArgument = (Typed.unTypedTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "singleVariantUnion"), - Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) - --- | DSL accessor for the body of hydra.build.format.LanguageName -unLanguageName :: Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm String -unLanguageName x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.build.format.LanguageName")), - Core.applicationArgument = (Typed.unTypedTerm x)})) - --- | DSL accessor for the body of hydra.build.format.Sha256Hash -unSha256Hash :: Typed.TypedTerm Format.Sha256Hash -> Typed.TypedTerm String -unSha256Hash x = - Typed.TypedTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.build.format.Sha256Hash")), - Core.applicationArgument = (Typed.unTypedTerm x)})) diff --git a/src/main/haskell/Hydra/Encode/Build/Assembly.hs b/src/main/haskell/Hydra/Encode/Build/Assembly.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Encode/Build/Assembly.hs +++ /dev/null @@ -1,82 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.build.assembly - -module Hydra.Encode.Build.Assembly where - -import qualified Hydra.Build.Assembly as Assembly -import qualified Hydra.Core as Core -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Encoder for hydra.build.assembly.AssemblyEntry -assemblyEntry :: Assembly.AssemblyEntry -> Core.Term -assemblyEntry x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.assembly.AssemblyEntry"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "sourceTree"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Assembly.assemblyEntrySourceTree x))}, - Core.Field { - Core.fieldName = (Core.Name "destTree"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Assembly.assemblyEntryDestTree x))}, - Core.Field { - Core.fieldName = (Core.Name "kind"), - Core.fieldTerm = (assemblyEntryKind (Assembly.assemblyEntryKind x))}, - Core.Field { - Core.fieldName = (Core.Name "exclude"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (\x2 -> Core.TermLiteral (Core.LiteralString x2)) xs)) (Assembly.assemblyEntryExclude x))}]}) - --- | Encoder for hydra.build.assembly.AssemblyEntryKind -assemblyEntryKind :: Assembly.AssemblyEntryKind -> Core.Term -assemblyEntryKind x = - case x of - Assembly.AssemblyEntryKindMerge -> Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntryKind"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "merge"), - Core.fieldTerm = Core.TermUnit}}) - Assembly.AssemblyEntryKindWipeThenCopy -> Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntryKind"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wipeThenCopy"), - Core.fieldTerm = Core.TermUnit}}) - Assembly.AssemblyEntryKindSymlinkTree -> Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntryKind"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "symlinkTree"), - Core.fieldTerm = Core.TermUnit}}) - Assembly.AssemblyEntryKindSymlinkDir -> Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.assembly.AssemblyEntryKind"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "symlinkDir"), - Core.fieldTerm = Core.TermUnit}}) - --- | Encoder for hydra.build.assembly.AssemblyPlan -assemblyPlan :: Assembly.AssemblyPlan -> Core.Term -assemblyPlan x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.assembly.AssemblyPlan"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "entries"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map assemblyEntry xs)) (Assembly.assemblyPlanEntries x))}, - Core.Field { - Core.fieldName = (Core.Name "keepPaths"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map keepPathEntry xs)) (Assembly.assemblyPlanKeepPaths x))}]}) - --- | Encoder for hydra.build.assembly.KeepPathEntry -keepPathEntry :: Assembly.KeepPathEntry -> Core.Term -keepPathEntry x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.assembly.KeepPathEntry"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "sourceSetDir"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Assembly.keepPathEntrySourceSetDir x))}, - Core.Field { - Core.fieldName = (Core.Name "relPath"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Assembly.keepPathEntryRelPath x))}]}) diff --git a/src/main/haskell/Hydra/Encode/Build/Benchresult.hs b/src/main/haskell/Hydra/Encode/Build/Benchresult.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Encode/Build/Benchresult.hs +++ /dev/null @@ -1,81 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.build.benchresult - -module Hydra.Encode.Build.Benchresult where - -import qualified Hydra.Build.Benchresult as Benchresult -import qualified Hydra.Core as Core -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 Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Encoder for hydra.build.benchresult.BenchMetadata -benchMetadata :: Benchresult.BenchMetadata -> Core.Term -benchMetadata x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.BenchMetadata"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "timestamp"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Benchresult.benchMetadataTimestamp x))}, - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Benchresult.benchMetadataLanguage x))}, - Core.Field { - Core.fieldName = (Core.Name "branch"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Benchresult.benchMetadataBranch x))}, - Core.Field { - Core.fieldName = (Core.Name "commit"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Benchresult.benchMetadataCommit x))}, - Core.Field { - Core.fieldName = (Core.Name "commitMessage"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Benchresult.benchMetadataCommitMessage x))}]}) - --- | Encoder for hydra.build.benchresult.GenBenchResult -genBenchResult :: Benchresult.GenBenchResult -> Core.Term -genBenchResult x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.GenBenchResult"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Benchresult.genBenchResultTarget x))}, - Core.Field { - Core.fieldName = (Core.Name "runs"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Benchresult.genBenchResultRuns x))}, - Core.Field { - Core.fieldName = (Core.Name "hosts"), - Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap (\x2 -> Core.TermLiteral (Core.LiteralString x2)) hostResult m)) (Benchresult.genBenchResultHosts x))}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map benchMetadata opt)) (Benchresult.genBenchResultMetadata x))}]}) - --- | Encoder for hydra.build.benchresult.HostResult -hostResult :: Benchresult.HostResult -> Core.Term -hostResult x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.HostResult"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "setupMs"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Benchresult.hostResultSetupMs x))}, - Core.Field { - Core.fieldName = (Core.Name "packages"), - Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap (\x2 -> Core.TermLiteral (Core.LiteralString x2)) runStats m)) (Benchresult.hostResultPackages x))}]}) - --- | Encoder for hydra.build.benchresult.RunStats -runStats :: Benchresult.RunStats -> Core.Term -runStats x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.benchresult.RunStats"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "runsMs"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) xs)) (Benchresult.runStatsRunsMs x))}, - Core.Field { - Core.fieldName = (Core.Name "medianMs"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Benchresult.runStatsMedianMs x))}]}) diff --git a/src/main/haskell/Hydra/Encode/Build/Comparereport.hs b/src/main/haskell/Hydra/Encode/Build/Comparereport.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Encode/Build/Comparereport.hs +++ /dev/null @@ -1,70 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.build.comparereport - -module Hydra.Encode.Build.Comparereport where - -import qualified Hydra.Build.Comparereport as Comparereport -import qualified Hydra.Core as Core -import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Encoder for hydra.build.comparereport.CompareReport -compareReport :: Comparereport.CompareReport -> Core.Term -compareReport x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.comparereport.CompareReport"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "rows"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map moduleCompare xs)) (Comparereport.compareReportRows x))}, - Core.Field { - Core.fieldName = (Core.Name "byteEqCount"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Comparereport.compareReportByteEqCount x))}, - Core.Field { - Core.fieldName = (Core.Name "total"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Comparereport.compareReportTotal x))}]}) - --- | Encoder for hydra.build.comparereport.CompareStatus -compareStatus :: Comparereport.CompareStatus -> Core.Term -compareStatus x = - case x of - Comparereport.CompareStatusByteEq -> Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.comparereport.CompareStatus"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "byteEq"), - Core.fieldTerm = Core.TermUnit}}) - Comparereport.CompareStatusDiffer -> Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.comparereport.CompareStatus"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "differ"), - Core.fieldTerm = Core.TermUnit}}) - Comparereport.CompareStatusMissing -> Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.comparereport.CompareStatus"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "missing"), - Core.fieldTerm = Core.TermUnit}}) - --- | Encoder for hydra.build.comparereport.ModuleCompare -moduleCompare :: Comparereport.ModuleCompare -> Core.Term -moduleCompare x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.comparereport.ModuleCompare"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Comparereport.moduleCompareModule x))}, - Core.Field { - Core.fieldName = (Core.Name "status"), - Core.fieldTerm = (compareStatus (Comparereport.moduleCompareStatus x))}, - Core.Field { - Core.fieldName = (Core.Name "ourSize"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Comparereport.moduleCompareOurSize x))}, - Core.Field { - Core.fieldName = (Core.Name "canonSize"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Comparereport.moduleCompareCanonSize x))}, - Core.Field { - Core.fieldName = (Core.Name "diffLines"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Comparereport.moduleCompareDiffLines x))}]}) diff --git a/src/main/haskell/Hydra/Encode/Build/Format.hs b/src/main/haskell/Hydra/Encode/Build/Format.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Encode/Build/Format.hs +++ /dev/null @@ -1,429 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.build.format - -module Hydra.Encode.Build.Format where - -import qualified Hydra.Build.Format as Format -import qualified Hydra.Core as Core -import qualified Hydra.Encode.Packaging as Packaging -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 Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) -import qualified Data.Scientific as Sci -import Data.Void - --- | Encoder for hydra.build.format.DefinitionNameConventionProfile -definitionNameConventionProfile :: Format.DefinitionNameConventionProfile -> Core.Term -definitionNameConventionProfile x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "severity"), - Core.fieldTerm = (severity (Format.definitionNameConventionProfileSeverity x))}, - Core.Field { - Core.fieldName = (Core.Name "allowUnderscores"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralBoolean x2)) (Format.definitionNameConventionProfileAllowUnderscores x))}]}) - --- | Encoder for hydra.build.format.DefinitionValidationProfile -definitionValidationProfile :: Format.DefinitionValidationProfile -> Core.Term -definitionValidationProfile x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "hasDescription"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map documentationProfile opt)) (Format.definitionValidationProfileHasDescription x))}, - Core.Field { - Core.fieldName = (Core.Name "ordering"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.definitionValidationProfileOrdering x))}, - Core.Field { - Core.fieldName = (Core.Name "nameConvention"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map definitionNameConventionProfile opt)) (Format.definitionValidationProfileNameConvention x))}, - Core.Field { - Core.fieldName = (Core.Name "notInModuleName"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.definitionValidationProfileNotInModuleName x))}, - Core.Field { - Core.fieldName = (Core.Name "duplicateName"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.definitionValidationProfileDuplicateName x))}]}) - --- | Encoder for hydra.build.format.DigestEntry -digestEntry :: Format.DigestEntry -> Core.Term -digestEntry x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.DigestEntry"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "kind"), - Core.fieldTerm = (digestKind (Format.digestEntryKind x))}, - Core.Field { - Core.fieldName = (Core.Name "hash"), - Core.fieldTerm = (sha256Hash (Format.digestEntryHash x))}]}) - --- | Encoder for hydra.build.format.DigestKind -digestKind :: Format.DigestKind -> Core.Term -digestKind x = - case x of - Format.DigestKindDslSource -> Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "dslSource"), - Core.fieldTerm = Core.TermUnit}}) - Format.DigestKindJsonFile -> Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "jsonFile"), - Core.fieldTerm = Core.TermUnit}}) - Format.DigestKindTargetFile -> Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "targetFile"), - Core.fieldTerm = Core.TermUnit}}) - Format.DigestKindRuntimeFile -> Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "runtimeFile"), - Core.fieldTerm = Core.TermUnit}}) - Format.DigestKindOther -> Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "other"), - Core.fieldTerm = Core.TermUnit}}) - --- | Encoder for hydra.build.format.DocumentationProfile -documentationProfile :: Format.DocumentationProfile -> Core.Term -documentationProfile x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.DocumentationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "severity"), - Core.fieldTerm = (severity (Format.documentationProfileSeverity x))}, - Core.Field { - Core.fieldName = (Core.Name "exemptDeprecated"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralBoolean x2)) (Format.documentationProfileExemptDeprecated x))}]}) - --- | Encoder for hydra.build.format.Generation -generation :: Format.Generation -> Core.Term -generation x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.Generation"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "generatorId"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.generationGeneratorId x))}, - Core.Field { - Core.fieldName = (Core.Name "mode"), - Core.fieldTerm = (generationMode (Format.generationMode x))}, - Core.Field { - Core.fieldName = (Core.Name "host"), - Core.fieldTerm = (languageName (Format.generationHost x))}, - Core.Field { - Core.fieldName = (Core.Name "hydraVersion"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map Packaging.version opt)) (Format.generationHydraVersion x))}, - Core.Field { - Core.fieldName = (Core.Name "revision"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map (\x2 -> Core.TermLiteral (Core.LiteralString x2)) opt)) (Format.generationRevision x))}, - Core.Field { - Core.fieldName = (Core.Name "timestamp"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map (\x2 -> Core.TermLiteral (Core.LiteralString x2)) opt)) (Format.generationTimestamp x))}]}) - --- | Encoder for hydra.build.format.GenerationMode -generationMode :: Format.GenerationMode -> Core.Term -generationMode x = - case x of - Format.GenerationModePublished -> Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.GenerationMode"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "published"), - Core.fieldTerm = Core.TermUnit}}) - Format.GenerationModeShim -> Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.GenerationMode"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "shim"), - Core.fieldTerm = Core.TermUnit}}) - --- | Encoder for hydra.build.format.HostOverride -hostOverride :: Format.HostOverride -> Core.Term -hostOverride x = - case x of - Format.HostOverrideLocal -> Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.HostOverride"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "local"), - Core.fieldTerm = Core.TermUnit}}) - Format.HostOverrideVersion v0 -> Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.HostOverride"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "version"), - Core.fieldTerm = (Packaging.version v0)}}) - --- | Encoder for hydra.build.format.InputDigest -inputDigest :: Format.InputDigest -> Core.Term -inputDigest x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "digestFormatVersion"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.inputDigestDigestFormatVersion x))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.inputDigestModuleFormatVersion x))}, - Core.Field { - Core.fieldName = (Core.Name "selfHash"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map sha256Hash opt)) (Format.inputDigestSelfHash x))}, - Core.Field { - Core.fieldName = (Core.Name "dependencyHashes"), - Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap Packaging.packageName sha256Hash m)) (Format.inputDigestDependencyHashes x))}, - Core.Field { - Core.fieldName = (Core.Name "moduleHashes"), - Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap Packaging.moduleName sha256Hash m)) (Format.inputDigestModuleHashes x))}]}) - --- | Encoder for hydra.build.format.LanguageName -languageName :: Format.LanguageName -> Core.Term -languageName x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.build.format.LanguageName"), - Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.unLanguageName x))}) - --- | Encoder for hydra.build.format.LanguageProfile -languageProfile :: Format.LanguageProfile -> Core.Term -languageProfile x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.LanguageProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.languageProfileName x))}, - Core.Field { - Core.fieldName = (Core.Name "coderPackage"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.languageProfileCoderPackage x))}, - Core.Field { - Core.fieldName = (Core.Name "family"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.languageProfileFamily x))}]}) - --- | Encoder for hydra.build.format.ModuleValidationProfile -moduleValidationProfile :: Format.ModuleValidationProfile -> Core.Term -moduleValidationProfile x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "definitions"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map definitionValidationProfile opt)) (Format.moduleValidationProfileDefinitions x))}, - Core.Field { - Core.fieldName = (Core.Name "nameConvention"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.moduleValidationProfileNameConvention x))}, - Core.Field { - Core.fieldName = (Core.Name "conflictingVariantName"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.moduleValidationProfileConflictingVariantName x))}]}) - --- | Encoder for hydra.build.format.OutputDigest -outputDigest :: Format.OutputDigest -> Core.Term -outputDigest x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "digestFormatVersion"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.outputDigestDigestFormatVersion x))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.outputDigestModuleFormatVersion x))}, - Core.Field { - Core.fieldName = (Core.Name "generator"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.outputDigestGenerator x))}, - Core.Field { - Core.fieldName = (Core.Name "generation"), - Core.fieldTerm = (generation (Format.outputDigestGeneration x))}, - Core.Field { - Core.fieldName = (Core.Name "selfHash"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map sha256Hash opt)) (Format.outputDigestSelfHash x))}, - Core.Field { - Core.fieldName = (Core.Name "dependencyHashes"), - Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap Packaging.packageName sha256Hash m)) (Format.outputDigestDependencyHashes x))}, - Core.Field { - Core.fieldName = (Core.Name "inputs"), - Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap (\x2 -> Core.TermLiteral (Core.LiteralString x2)) digestEntry m)) (Format.outputDigestInputs x))}, - Core.Field { - Core.fieldName = (Core.Name "outputs"), - Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap (\x2 -> Core.TermLiteral (Core.LiteralString x2)) digestEntry m)) (Format.outputDigestOutputs x))}]}) - --- | Encoder for hydra.build.format.PackageDescriptor -packageDescriptor :: Format.PackageDescriptor -> Core.Term -packageDescriptor x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "packageFormatVersion"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.packageDescriptorPackageFormatVersion x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Packaging.packageName (Format.packageDescriptorName x))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.packageDescriptorDescription x))}, - Core.Field { - Core.fieldName = (Core.Name "sourceLanguage"), - Core.fieldTerm = (languageName (Format.packageDescriptorSourceLanguage x))}, - Core.Field { - Core.fieldName = (Core.Name "targetLanguages"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map (\xs -> Core.TermList (Lists.map languageName xs)) opt)) (Format.packageDescriptorTargetLanguages x))}, - Core.Field { - Core.fieldName = (Core.Name "dependencies"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Packaging.packageName xs)) (Format.packageDescriptorDependencies x))}, - Core.Field { - Core.fieldName = (Core.Name "validation"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map packageValidationConfiguration opt)) (Format.packageDescriptorValidation x))}]}) - --- | Encoder for hydra.build.format.PackageManifest -packageManifest :: Format.PackageManifest -> Core.Term -packageManifest x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "manifestFormatVersion"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.packageManifestManifestFormatVersion x))}, - Core.Field { - Core.fieldName = (Core.Name "moduleFormatVersion"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.packageManifestModuleFormatVersion x))}, - Core.Field { - Core.fieldName = (Core.Name "package"), - Core.fieldTerm = (Packaging.packageName (Format.packageManifestPackage x))}, - Core.Field { - Core.fieldName = (Core.Name "mainModules"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Packaging.moduleName xs)) (Format.packageManifestMainModules x))}, - Core.Field { - Core.fieldName = (Core.Name "testModules"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Packaging.moduleName xs)) (Format.packageManifestTestModules x))}, - Core.Field { - Core.fieldName = (Core.Name "mainDslModules"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Packaging.moduleName xs)) (Format.packageManifestMainDslModules x))}, - Core.Field { - Core.fieldName = (Core.Name "mainEncodingModules"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Packaging.moduleName xs)) (Format.packageManifestMainEncodingModules x))}]}) - --- | Encoder for hydra.build.format.PackageValidationConfiguration -packageValidationConfiguration :: Format.PackageValidationConfiguration -> Core.Term -packageValidationConfiguration x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "package"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map packageValidationProfile opt)) (Format.packageValidationConfigurationPackage x))}, - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map moduleValidationProfile opt)) (Format.packageValidationConfigurationModule x))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map typeValidationProfile opt)) (Format.packageValidationConfigurationType x))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map termValidationProfile opt)) (Format.packageValidationConfigurationTerm x))}]}) - --- | Encoder for hydra.build.format.PackageValidationProfile -packageValidationProfile :: Format.PackageValidationProfile -> Core.Term -packageValidationProfile x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "conflictingModuleName"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.packageValidationProfileConflictingModuleName x))}, - Core.Field { - Core.fieldName = (Core.Name "duplicateModuleName"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.packageValidationProfileDuplicateModuleName x))}, - Core.Field { - Core.fieldName = (Core.Name "nameConvention"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.packageValidationProfileNameConvention x))}]}) - --- | Encoder for hydra.build.format.RepositoryDescriptor -repositoryDescriptor :: Format.RepositoryDescriptor -> Core.Term -repositoryDescriptor x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "currentVersion"), - Core.fieldTerm = (Packaging.version (Format.repositoryDescriptorCurrentVersion x))}, - Core.Field { - Core.fieldName = (Core.Name "hostVersion"), - Core.fieldTerm = (Packaging.version (Format.repositoryDescriptorHostVersion x))}, - Core.Field { - Core.fieldName = (Core.Name "hostOverrides"), - Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap languageName hostOverride m)) (Format.repositoryDescriptorHostOverrides x))}, - Core.Field { - Core.fieldName = (Core.Name "group"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.repositoryDescriptorGroup x))}, - Core.Field { - Core.fieldName = (Core.Name "author"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.repositoryDescriptorAuthor x))}, - Core.Field { - Core.fieldName = (Core.Name "url"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.repositoryDescriptorUrl x))}, - Core.Field { - Core.fieldName = (Core.Name "license"), - Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.repositoryDescriptorLicense x))}, - Core.Field { - Core.fieldName = (Core.Name "packages"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Packaging.packageName xs)) (Format.repositoryDescriptorPackages x))}]}) - --- | Encoder for hydra.build.format.Severity -severity :: Format.Severity -> Core.Term -severity x = - case x of - Format.SeverityError -> Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.Severity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "error"), - Core.fieldTerm = Core.TermUnit}}) - Format.SeverityWarning -> Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.build.format.Severity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "warning"), - Core.fieldTerm = Core.TermUnit}}) - --- | Encoder for hydra.build.format.Sha256Hash -sha256Hash :: Format.Sha256Hash -> Core.Term -sha256Hash x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.build.format.Sha256Hash"), - Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.unSha256Hash x))}) - --- | Encoder for hydra.build.format.TermValidationProfile -termValidationProfile :: Format.TermValidationProfile -> Core.Term -termValidationProfile x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.TermValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "duplicateBinding"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.termValidationProfileDuplicateBinding x))}, - Core.Field { - Core.fieldName = (Core.Name "emptyTermAnnotation"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.termValidationProfileEmptyTermAnnotation x))}, - Core.Field { - Core.fieldName = (Core.Name "undefinedVariable"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.termValidationProfileUndefinedVariable x))}]}) - --- | Encoder for hydra.build.format.TypeValidationProfile -typeValidationProfile :: Format.TypeValidationProfile -> Core.Term -typeValidationProfile x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "emptyAnnotation"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.typeValidationProfileEmptyAnnotation x))}, - Core.Field { - Core.fieldName = (Core.Name "duplicateField"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.typeValidationProfileDuplicateField x))}, - Core.Field { - Core.fieldName = (Core.Name "singleVariantUnion"), - Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.typeValidationProfileSingleVariantUnion x))}]})