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.2 +version: 0.17.3 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 @@ -27,9 +27,15 @@ library exposed-modules: + Hydra.Build.Format + Hydra.Build.Libraries + Hydra.Build.ManifestWriter Hydra.Build.Modules Hydra.Build.Reconcile Hydra.Build.Routing + Hydra.Decode.Build.Format + Hydra.Dsl.Build.Format + Hydra.Encode.Build.Format other-modules: Paths_hydra_build hs-source-dirs: @@ -37,6 +43,6 @@ build-depends: base >=4.19.0 && <4.22 , containers >=0.6.7 && <0.8 - , hydra-kernel ==0.17.2 + , hydra-kernel ==0.17.3 , scientific >=0.3.7 && <0.4 default-language: Haskell2010 diff --git a/src/main/haskell/Hydra/Build/Format.hs b/src/main/haskell/Hydra/Build/Format.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Build/Format.hs @@ -0,0 +1,470 @@ +-- 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 + +module Hydra.Build.Format where + +import qualified Hydra.Core as Core +import qualified Hydra.Packaging as Packaging +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Map as M + +-- | Configuration for the definition-name-convention check +data DefinitionNameConventionProfile = + DefinitionNameConventionProfile { + -- | How a finding of this check is treated + definitionNameConventionProfileSeverity :: Severity, + -- | Whether underscores are permitted in definition names + definitionNameConventionProfileAllowUnderscores :: Bool} + deriving (Eq, Ord, Read, Show) + +_DefinitionNameConventionProfile = Core.Name "hydra.build.format.DefinitionNameConventionProfile" + +_DefinitionNameConventionProfile_severity = Core.Name "severity" + +_DefinitionNameConventionProfile_allowUnderscores = Core.Name "allowUnderscores" + +-- | Validation rules applying to individual definitions within a module. Absent fields mean the corresponding check is not configured. +data DefinitionValidationProfile = + DefinitionValidationProfile { + -- | Configuration for the definition-documentation check + definitionValidationProfileHasDescription :: (Maybe DocumentationProfile), + -- | Whether definitions must appear in alphabetical order + definitionValidationProfileOrdering :: (Maybe Severity), + -- | Configuration for the definition-name-convention check + definitionValidationProfileNameConvention :: (Maybe DefinitionNameConventionProfile), + -- | Whether a definition name may duplicate part of its module name + definitionValidationProfileNotInModuleName :: (Maybe Severity), + -- | Whether duplicate definition names within a module are reported + definitionValidationProfileDuplicateName :: (Maybe Severity)} + deriving (Eq, Ord, Read, Show) + +_DefinitionValidationProfile = Core.Name "hydra.build.format.DefinitionValidationProfile" + +_DefinitionValidationProfile_hasDescription = Core.Name "hasDescription" + +_DefinitionValidationProfile_ordering = Core.Name "ordering" + +_DefinitionValidationProfile_nameConvention = Core.Name "nameConvention" + +_DefinitionValidationProfile_notInModuleName = Core.Name "notInModuleName" + +_DefinitionValidationProfile_duplicateName = Core.Name "duplicateName" + +-- | One file's classification and content hash within a digest +data DigestEntry = + DigestEntry { + -- | The kind of artifact recorded + digestEntryKind :: DigestKind, + -- | The SHA-256 hash of the file content + digestEntryHash :: Sha256Hash} + deriving (Eq, Ord, Read, Show) + +_DigestEntry = Core.Name "hydra.build.format.DigestEntry" + +_DigestEntry_kind = Core.Name "kind" + +_DigestEntry_hash = Core.Name "hash" + +-- | The kind of artifact recorded in a digest entry. Lets a single digest mix typed entries without losing the discriminator. +data DigestKind = + -- | A DSL source file under a package's src/main source tree + DigestKindDslSource | + -- | A JSON file under dist/json/ + DigestKindJsonFile | + -- | A generated source file under dist// + DigestKindTargetFile | + -- | A hand-written runtime support file copied into the distribution + DigestKindRuntimeFile | + -- | Anything else (escape hatch; unknown kinds round-trip as this variant) + DigestKindOther + deriving (Eq, Ord, Read, Show) + +_DigestKind = Core.Name "hydra.build.format.DigestKind" + +_DigestKind_dslSource = Core.Name "dslSource" + +_DigestKind_jsonFile = Core.Name "jsonFile" + +_DigestKind_targetFile = Core.Name "targetFile" + +_DigestKind_runtimeFile = Core.Name "runtimeFile" + +_DigestKind_other = Core.Name "other" + +-- | Configuration for the definition-documentation check +data DocumentationProfile = + DocumentationProfile { + -- | How a finding of this check is treated + documentationProfileSeverity :: Severity, + -- | Whether deprecated definitions are exempt from the documentation requirement + documentationProfileExemptDeprecated :: Bool} + deriving (Eq, Ord, Read, Show) + +_DocumentationProfile = Core.Name "hydra.build.format.DocumentationProfile" + +_DocumentationProfile_severity = Core.Name "severity" + +_DocumentationProfile_exemptDeprecated = Core.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 = + Generation { + -- | The gating cache key identifying the generator that produced the outputs + generationGeneratorId :: String, + -- | Whether the artifact was produced by a published host or a locally-built migration shim + generationMode :: GenerationMode, + -- | The producing host language (informational) + generationHost :: LanguageName, + -- | The release version of the producing host (informational; omitted for shim builds) + generationHydraVersion :: (Maybe Packaging.Version), + -- | The producing worktree's revision, as with "-dirty" appended when the tree has uncommitted changes (informational; required for shim builds) + generationRevision :: (Maybe String), + -- | The ISO-8601 UTC time of generation (informational; non-deterministic across byte-identical rebuilds) + generationTimestamp :: (Maybe String)} + deriving (Eq, Ord, Read, Show) + +_Generation = Core.Name "hydra.build.format.Generation" + +_Generation_generatorId = Core.Name "generatorId" + +_Generation_mode = Core.Name "mode" + +_Generation_host = Core.Name "host" + +_Generation_hydraVersion = Core.Name "hydraVersion" + +_Generation_revision = Core.Name "revision" + +_Generation_timestamp = Core.Name "timestamp" + +-- | The provenance class of a generated artifact +data GenerationMode = + -- | Produced by a published, versioned host + GenerationModePublished | + -- | Produced by a locally-built migration shim, ahead of any published host + GenerationModeShim + deriving (Eq, Ord, Read, Show) + +_GenerationMode = Core.Name "hydra.build.format.GenerationMode" + +_GenerationMode_published = Core.Name "published" + +_GenerationMode_shim = Core.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 = + -- | Build and consume the host locally from source rather than from the package registry + HostOverrideLocal | + -- | Pin the host to a specific published version + HostOverrideVersion Packaging.Version + deriving (Eq, Ord, Read, Show) + +_HostOverride = Core.Name "hydra.build.format.HostOverride" + +_HostOverride_local = Core.Name "local" + +_HostOverride_version = Core.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 = + InputDigest { + -- | The version of this digest file's own schema + inputDigestDigestFormatVersion :: Int, + -- | The version of the JSON encoding of the sibling module files + inputDigestModuleFormatVersion :: Int, + -- | A deterministic hash over all of the package's per-module hashes (absent in legacy digests) + inputDigestSelfHash :: (Maybe Sha256Hash), + -- | For each declared dependency package, that package's selfHash as recorded at write time + inputDigestDependencyHashes :: (M.Map Packaging.PackageName Sha256Hash), + -- | The hash of each module's source, keyed by module name + inputDigestModuleHashes :: (M.Map Packaging.ModuleName Sha256Hash)} + deriving (Eq, Ord, Read, Show) + +_InputDigest = Core.Name "hydra.build.format.InputDigest" + +_InputDigest_digestFormatVersion = Core.Name "digestFormatVersion" + +_InputDigest_moduleFormatVersion = Core.Name "moduleFormatVersion" + +_InputDigest_selfHash = Core.Name "selfHash" + +_InputDigest_dependencyHashes = Core.Name "dependencyHashes" + +_InputDigest_moduleHashes = Core.Name "moduleHashes" + +-- | The name of a source or target language in Hydra's build system, e.g. "haskell", "java", or "python" +newtype LanguageName = + LanguageName { + unLanguageName :: String} + deriving (Eq, Ord, Read, Show) + +_LanguageName = Core.Name "hydra.build.format.LanguageName" + +-- | Validation rules applying to a module as a whole. Absent fields mean the corresponding check is not configured. +data ModuleValidationProfile = + ModuleValidationProfile { + -- | Validation rules applying to the module's individual definitions + moduleValidationProfileDefinitions :: (Maybe DefinitionValidationProfile), + -- | Whether module names must follow naming conventions + moduleValidationProfileNameConvention :: (Maybe Severity), + -- | Whether union variant names conflicting across the module are reported + moduleValidationProfileConflictingVariantName :: (Maybe Severity)} + deriving (Eq, Ord, Read, Show) + +_ModuleValidationProfile = Core.Name "hydra.build.format.ModuleValidationProfile" + +_ModuleValidationProfile_definitions = Core.Name "definitions" + +_ModuleValidationProfile_nameConvention = Core.Name "nameConvention" + +_ModuleValidationProfile_conflictingVariantName = Core.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 = + OutputDigest { + -- | The version of this digest file's own schema + outputDigestDigestFormatVersion :: Int, + -- | The version of the JSON encoding of the module files this digest governs + outputDigestModuleFormatVersion :: Int, + -- | The flat gating generator identity (a compatibility duplicate of generation.generatorId) + outputDigestGenerator :: String, + -- | The structured generation-provenance record + outputDigestGeneration :: Generation, + -- | The input package's selfHash as recorded at refresh time (absent in legacy digests) + outputDigestSelfHash :: (Maybe Sha256Hash), + -- | For each declared dependency package, that package's selfHash as recorded at refresh time + outputDigestDependencyHashes :: (M.Map Packaging.PackageName Sha256Hash), + -- | Every input file's kind and hash, keyed by worktree-relative path + outputDigestInputs :: (M.Map String DigestEntry), + -- | Every output file's kind and hash, keyed by path relative to the output directory + outputDigestOutputs :: (M.Map String DigestEntry)} + deriving (Eq, Ord, Read, Show) + +_OutputDigest = Core.Name "hydra.build.format.OutputDigest" + +_OutputDigest_digestFormatVersion = Core.Name "digestFormatVersion" + +_OutputDigest_moduleFormatVersion = Core.Name "moduleFormatVersion" + +_OutputDigest_generator = Core.Name "generator" + +_OutputDigest_generation = Core.Name "generation" + +_OutputDigest_selfHash = Core.Name "selfHash" + +_OutputDigest_dependencyHashes = Core.Name "dependencyHashes" + +_OutputDigest_inputs = Core.Name "inputs" + +_OutputDigest_outputs = Core.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 = + PackageDescriptor { + -- | The version of this descriptor file's schema + packageDescriptorPackageFormatVersion :: Int, + -- | The unique name of the package, e.g. "hydra-kernel" + packageDescriptorName :: Packaging.PackageName, + -- | A concise human-readable summary of the package + packageDescriptorDescription :: String, + -- | The language in which the package's DSL sources are authored + packageDescriptorSourceLanguage :: LanguageName, + -- | The target languages for which distributions of this package are generated. When absent, the default target set applies. + packageDescriptorTargetLanguages :: (Maybe [LanguageName]), + -- | The names of the packages this package depends upon + packageDescriptorDependencies :: [Packaging.PackageName], + -- | Optional per-package validation configuration. When absent, the validation engine's defaults apply. + packageDescriptorValidation :: (Maybe PackageValidationConfiguration)} + deriving (Eq, Ord, Read, Show) + +_PackageDescriptor = Core.Name "hydra.build.format.PackageDescriptor" + +_PackageDescriptor_packageFormatVersion = Core.Name "packageFormatVersion" + +_PackageDescriptor_name = Core.Name "name" + +_PackageDescriptor_description = Core.Name "description" + +_PackageDescriptor_sourceLanguage = Core.Name "sourceLanguage" + +_PackageDescriptor_targetLanguages = Core.Name "targetLanguages" + +_PackageDescriptor_dependencies = Core.Name "dependencies" + +_PackageDescriptor_validation = Core.Name "validation" + +-- | A generated-source manifest (dist///src///manifest.json): the list of modules generated into a distribution package, partitioned by role. +data PackageManifest = + PackageManifest { + -- | The version of this manifest file's schema + packageManifestManifestFormatVersion :: Int, + -- | The version of the JSON encoding of the sibling module files + packageManifestModuleFormatVersion :: Int, + -- | The name of the package this manifest describes + packageManifestPackage :: Packaging.PackageName, + -- | All main-source-set modules in the package + packageManifestMainModules :: [Packaging.ModuleName], + -- | All test-source-set modules in the package + packageManifestTestModules :: [Packaging.ModuleName], + -- | The subset of main modules which define type schemas and give rise to generated DSL wrapper modules + packageManifestMainDslModules :: [Packaging.ModuleName], + -- | The subset of main modules for which encoding and decoding modules are generated + packageManifestMainEncodingModules :: [Packaging.ModuleName]} + deriving (Eq, Ord, Read, Show) + +_PackageManifest = Core.Name "hydra.build.format.PackageManifest" + +_PackageManifest_manifestFormatVersion = Core.Name "manifestFormatVersion" + +_PackageManifest_moduleFormatVersion = Core.Name "moduleFormatVersion" + +_PackageManifest_package = Core.Name "package" + +_PackageManifest_mainModules = Core.Name "mainModules" + +_PackageManifest_testModules = Core.Name "testModules" + +_PackageManifest_mainDslModules = Core.Name "mainDslModules" + +_PackageManifest_mainEncodingModules = Core.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 = + PackageValidationConfiguration { + -- | Validation rules applying to the package as a whole + packageValidationConfigurationPackage :: (Maybe PackageValidationProfile), + -- | Validation rules applying to each module + packageValidationConfigurationModule :: (Maybe ModuleValidationProfile), + -- | Validation rules applying to type-definition bodies + packageValidationConfigurationType :: (Maybe TypeValidationProfile), + -- | Validation rules applying to term-definition bodies + packageValidationConfigurationTerm :: (Maybe TermValidationProfile)} + deriving (Eq, Ord, Read, Show) + +_PackageValidationConfiguration = Core.Name "hydra.build.format.PackageValidationConfiguration" + +_PackageValidationConfiguration_package = Core.Name "package" + +_PackageValidationConfiguration_module = Core.Name "module" + +_PackageValidationConfiguration_type = Core.Name "type" + +_PackageValidationConfiguration_term = Core.Name "term" + +-- | Validation rules applying to a package as a whole. Absent fields mean the corresponding check is not configured. +data PackageValidationProfile = + PackageValidationProfile { + -- | Whether module names conflicting across the package are reported + packageValidationProfileConflictingModuleName :: (Maybe Severity), + -- | Whether duplicate module names within the package are reported + packageValidationProfileDuplicateModuleName :: (Maybe Severity), + -- | Whether package names must follow naming conventions + packageValidationProfileNameConvention :: (Maybe Severity)} + deriving (Eq, Ord, Read, Show) + +_PackageValidationProfile = Core.Name "hydra.build.format.PackageValidationProfile" + +_PackageValidationProfile_conflictingModuleName = Core.Name "conflictingModuleName" + +_PackageValidationProfile_duplicateModuleName = Core.Name "duplicateModuleName" + +_PackageValidationProfile_nameConvention = Core.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 = + RepositoryDescriptor { + -- | The version currently under development + repositoryDescriptorCurrentVersion :: Packaging.Version, + -- | The published host version consumed by default when generating code + repositoryDescriptorHostVersion :: Packaging.Version, + -- | Per-host-language overrides of the default published-host consumption + repositoryDescriptorHostOverrides :: (M.Map LanguageName HostOverride), + -- | The group identifier under which artifacts are published, e.g. a Maven group id + repositoryDescriptorGroup :: String, + -- | The author attribution for published artifacts + repositoryDescriptorAuthor :: String, + -- | The URL of the project + repositoryDescriptorUrl :: String, + -- | The license identifier for published artifacts, e.g. "Apache-2.0" + repositoryDescriptorLicense :: String, + -- | The names of the repository's source packages + repositoryDescriptorPackages :: [Packaging.PackageName]} + deriving (Eq, Ord, Read, Show) + +_RepositoryDescriptor = Core.Name "hydra.build.format.RepositoryDescriptor" + +_RepositoryDescriptor_currentVersion = Core.Name "currentVersion" + +_RepositoryDescriptor_hostVersion = Core.Name "hostVersion" + +_RepositoryDescriptor_hostOverrides = Core.Name "hostOverrides" + +_RepositoryDescriptor_group = Core.Name "group" + +_RepositoryDescriptor_author = Core.Name "author" + +_RepositoryDescriptor_url = Core.Name "url" + +_RepositoryDescriptor_license = Core.Name "license" + +_RepositoryDescriptor_packages = Core.Name "packages" + +-- | How a validation finding is treated +data Severity = + SeverityError | + SeverityWarning + deriving (Eq, Ord, Read, Show) + +_Severity = Core.Name "hydra.build.format.Severity" + +_Severity_error = Core.Name "error" + +_Severity_warning = Core.Name "warning" + +-- | A SHA-256 hash in lowercase hexadecimal notation +newtype Sha256Hash = + Sha256Hash { + unSha256Hash :: String} + deriving (Eq, Ord, Read, Show) + +_Sha256Hash = Core.Name "hydra.build.format.Sha256Hash" + +-- | Validation rules applying to term-definition bodies. Absent fields mean the corresponding check is not configured. +data TermValidationProfile = + TermValidationProfile { + -- | Whether duplicate let bindings are reported + termValidationProfileDuplicateBinding :: (Maybe Severity), + -- | Whether empty term annotations are reported + termValidationProfileEmptyTermAnnotation :: (Maybe Severity), + -- | Whether references to undefined variables are reported + termValidationProfileUndefinedVariable :: (Maybe Severity)} + deriving (Eq, Ord, Read, Show) + +_TermValidationProfile = Core.Name "hydra.build.format.TermValidationProfile" + +_TermValidationProfile_duplicateBinding = Core.Name "duplicateBinding" + +_TermValidationProfile_emptyTermAnnotation = Core.Name "emptyTermAnnotation" + +_TermValidationProfile_undefinedVariable = Core.Name "undefinedVariable" + +-- | Validation rules applying to type-definition bodies. Absent fields mean the corresponding check is not configured. +data TypeValidationProfile = + TypeValidationProfile { + -- | Whether empty type annotations are reported + typeValidationProfileEmptyAnnotation :: (Maybe Severity), + -- | Whether duplicate field names within a record or union are reported + typeValidationProfileDuplicateField :: (Maybe Severity), + -- | Whether single-variant unions are reported + typeValidationProfileSingleVariantUnion :: (Maybe Severity)} + deriving (Eq, Ord, Read, Show) + +_TypeValidationProfile = Core.Name "hydra.build.format.TypeValidationProfile" + +_TypeValidationProfile_emptyAnnotation = Core.Name "emptyAnnotation" + +_TypeValidationProfile_duplicateField = Core.Name "duplicateField" + +_TypeValidationProfile_singleVariantUnion = Core.Name "singleVariantUnion" diff --git a/src/main/haskell/Hydra/Build/Libraries.hs b/src/main/haskell/Hydra/Build/Libraries.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Build/Libraries.hs @@ -0,0 +1,67 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | The translingual expected-libraries registry: every hydra.lib. module name every self-hosting host must register, load, and test. See https://github.com/CategoricalData/hydra/issues/533 + +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 Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci + +-- | Every hydra.lib. module name every self-hosting host must register +expectedLibraries :: [String] +expectedLibraries = + [ + "chars", + "effects", + "eithers", + "equality", + "files", + "functions", + "hashing", + "lists", + "literals", + "logic", + "maps", + "math", + "optionals", + "ordering", + "pairs", + "regex", + "sets", + "strings", + "system", + "text"] + +-- | Whether a bare sub-namespace name is a member of expectedLibraries +isExpectedLibrary :: String -> Bool +isExpectedLibrary sub = Lists.member sub expectedLibraries diff --git a/src/main/haskell/Hydra/Build/ManifestWriter.hs b/src/main/haskell/Hydra/Build/ManifestWriter.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Build/ManifestWriter.hs @@ -0,0 +1,57 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Per-package manifest.json field-assembly and serialization logic shared by the code-generation drivers + +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 Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci + +-- | 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 pkg mainMods dslMods encMods testMods = + Model.ValueObject [ + ("mainDslModules", (sortedNamespaces dslMods)), + ("mainEncodingModules", (sortedNamespaces encMods)), + ("mainModules", (sortedNamespaces mainMods)), + ("manifestFormatVersion", (Model.ValueNumber (Literals.bigintToDecimal 1))), + ("package", (Model.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 mods = + + let names = Lists.sort (Lists.map (\m -> Packaging.unModuleName (Packaging.moduleName m)) mods) + in (Model.ValueArray (Lists.map (\n -> Model.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 @@ -17,10 +17,10 @@ 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.Pairs as Pairs import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Packaging as Packaging @@ -45,7 +45,7 @@ -- | Deduplicate a list of strings, preserving first-occurrence order dedupPreservingOrder :: Eq t0 => ([t0] -> [t0]) -dedupPreservingOrder xs = Lists.nub xs +dedupPreservingOrder xs = Lists.distinct xs -- | Keep only modules outside the hydra.* and hydra.json.yaml.* namespaces filterKernelModules :: [Packaging.Module] -> [Packaging.Module] @@ -71,7 +71,7 @@ secondLevelDir rel = let parts = Strings.splitOn "/" rel - in (Logic.ifElse (Equality.lt (Lists.length parts) 2) Nothing (Just (Strings.intercalate "/" (Lists.take 2 parts)))) + in (Logic.ifElse (Ordering.lt (Lists.length parts) 2) Nothing (Just (Strings.join "/" (Lists.take 2 parts)))) -- | Strip System F type annotations from every module in a list stripAllTermTypes :: [Packaging.Module] -> [Packaging.Module] 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 @@ -22,6 +22,7 @@ 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 @@ -49,9 +50,9 @@ extensionOf path = let segs = Strings.splitOn "/" path - in (Optionals.cases (Lists.maybeLast segs) Nothing (\fileName -> + in (Optionals.cases (Lists.last segs) Nothing (\fileName -> let dotParts = Strings.splitOn "." fileName - in (Logic.ifElse (Equality.gt (Lists.length dotParts) 1) (Lists.maybeLast dotParts) Nothing))) + in (Logic.ifElse (Ordering.gt (Lists.length dotParts) 1) (Lists.last dotParts) Nothing))) -- | Whether a relative path lies under at least one prefix, matched segment-wise isUnderAnyPrefix :: S.Set String -> String -> Bool @@ -65,7 +66,7 @@ -- | The keep-set of relative JSON paths (moduleNameToPath(ns) ++ .json) for written modules keepPathsForModules :: [Packaging.ModuleName] -> S.Set String keepPathsForModules mods = - Sets.fromList (Lists.map (\m -> Strings.cat [ + Sets.fromList (Lists.map (\m -> Strings.concat [ Codegen.moduleNameToPath m, ".json"]) mods) @@ -93,4 +94,4 @@ secondLevelDir path = let segs = Strings.splitOn "/" path - in (Logic.ifElse (Equality.gte (Lists.length segs) 2) (Just (Strings.intercalate "/" (Lists.take 2 segs))) Nothing) + in (Logic.ifElse (Ordering.gte (Lists.length segs) 2) (Just (Strings.join "/" (Lists.take 2 segs))) Nothing) 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 @@ -75,13 +75,13 @@ groupByPackageIn rm mods = let step = - \acc -> \m -> Eithers.bind acc (\grouped -> Eithers.bind (namespaceToPackageIn rm (Packaging.moduleName m)) (\pkg -> Right (Maps.alter (\mods0 -> Just (Lists.cons m (Optionals.fromOptional [] mods0))) pkg grouped))) + \acc -> \m -> Eithers.bind acc (\grouped -> Eithers.bind (namespaceToPackageIn rm (Packaging.moduleName m)) (\pkg -> Right (Maps.alter (\mods0 -> Just (Lists.cons m (Optionals.withDefault [] mods0))) pkg grouped))) in (Eithers.map (\grouped -> Maps.toList grouped) (Lists.foldl step (Right Maps.empty) mods)) -- | Map a module name to the package that owns it, failing loudly if unrouted namespaceToPackageIn :: M.Map Packaging.ModuleName t0 -> Packaging.ModuleName -> Either Errors.Error t0 namespaceToPackageIn rm ns = - Optionals.cases (Maps.lookup ns rm) (Left (Errors.ErrorOther (Errors.OtherError (Strings.cat [ + Optionals.cases (Maps.lookup ns rm) (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ "unrouted module: ", (Packaging.unModuleName ns), " is not declared in any package's manifest (RoutingMap). Add it to the owning package's Manifest.mainModules."])))) (\p -> Right p) @@ -92,9 +92,9 @@ let parts = Strings.splitOn "." (Packaging.unModuleName ns) fallback = - Packaging.ModuleName (Strings.cat [ + Packaging.ModuleName (Strings.concat [ "hydra.sources.", (Packaging.unModuleName ns)]) - in (Optionals.cases (Lists.uncons parts) fallback (\uc -> Packaging.ModuleName (Strings.cat [ + in (Optionals.cases (Lists.uncons parts) fallback (\uc -> Packaging.ModuleName (Strings.concat [ "hydra.sources.", - (Strings.intercalate "." (Pairs.second uc))]))) + (Strings.join "." (Pairs.second uc))]))) diff --git a/src/main/haskell/Hydra/Decode/Build/Format.hs b/src/main/haskell/Hydra/Decode/Build/Format.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Build/Format.hs @@ -0,0 +1,415 @@ +-- 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, map, pure, sum) +import qualified Data.Scientific as Sci + +-- | 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.cases (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.cases (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.cases (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.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.cases (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/Format.hs b/src/main/haskell/Hydra/Dsl/Build/Format.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Build/Format.hs @@ -0,0 +1,3988 @@ +-- 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, map, pure, sum) +import qualified Data.Scientific as Sci +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.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/Format.hs b/src/main/haskell/Hydra/Encode/Build/Format.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Build/Format.hs @@ -0,0 +1,412 @@ +-- 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, map, pure, sum) +import qualified Data.Scientific as Sci + +-- | 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.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))}]})